docs: audit all 'what's next' sections against the code; fix stale comments

Verified every deferred item in the nine docs with a what's-next section and
marked what has since landed (reaper, per-process CR3, higher-half kernel,
kernel heap, contiguous frame alloc, RSDP capture, cap-passing, driver restart
with backoff, PS/2 keyboard) while keeping the genuinely open items. Also
corrects interrupts.md's claim that the keyboard skipped the IO-APIC, and
updates scheduler.zig/heap.zig comments that predated the reaper and the big
kernel lock.

system/kernel/heap.zig

@@ -9,8 +9,9 @@
 //! of free blocks, split on allocation and coalesced with neighbours on free. It
 //! is exposed as a std.mem.Allocator, so the kernel can use std containers.
 //!
-//! Not yet concurrency-safe: it assumes a single caller and no allocation from
-//! interrupt handlers (ours don't). A lock comes with threads/SMP.
+//! No lock of its own: every kernel entry takes the big kernel lock (sync.zig),
+//! which serializes all heap access. A private lock only becomes necessary if
+//! the big lock is ever split.
 
 const std = @import("std");
 const abi = @import("abi");

system/kernel/scheduler.zig

@@ -942,8 +942,9 @@ pub fn setPreemption(enabled: bool) void {
     preemption_enabled = enabled;
 }
 
-/// End the current task and switch away for good; never returns. The task's stack
-/// is leaked for now (no reaper yet). Acquires the kernel lock and hands it off to
+/// End the current task and switch away for good; never returns. The task goes on
+/// its core's reap list; the tick-time reaper frees the stack and recycles the
+/// slot. Acquires the kernel lock and hands it off to
 /// the task we switch into (which releases it) — this frame never returns to leave.
 pub fn exit() noreturn {
     _ = sync.enter();
@@ -965,7 +966,7 @@ pub fn exit() noreturn {
 /// dying task's kernel stack (in the shared kernel half, so it survives the CR3
 /// switch to the kernel tables that must happen before we free the process's own
 /// tables — we can't free the page tables we're standing on). The kernel stack
-/// itself is leaked, as in `exit` (no reaper yet). Never returns.
+/// itself is reaped later, as in `exit`. Never returns.
 pub fn exitUser() noreturn {
     _ = sync.enter();
     exitUserLocked();