refactor: retire bespoke Task async; one stack behind context.io (Phase 5)

Converge the Io unification (PLAN-IO-UNIFY Phase 5). The bespoke fiber-task layer
in sched.sx — Task / TaskState / TaskErr / go / wait / cancel(Task), plus
Scheduler.task_allocs and its deinit bookkeeping (~130 lines) — is removed. There
is now ONE async stack: context.io.async / await / cancel / race / sleep over the
Io protocol, with the Scheduler as the fiber Io's engine + driver (spawn /
yield_now / suspend_self / wake / run / block_on_fd remain as the raw primitives;
race stays in sched.sx because it needs meta.sx's make_enum/make_variant).

Migrated the four go/wait users to context.io:
- 1813 — interleave + cancel (sequence 1 2 3 42 100 -99)
- 1817 — m1 end-to-end (completion in deadline order, sum 123)
- 1819 — double-AWAIT loud-abort via the Future one-awaiter guard
- 1820 — deinit: dropped the go/task_allocs tasks; now exercises timers/io_waiters/
  kq cleanup (freed=2, live=3 = the documented per-spawn closure-env residual)

Updated readme.md (the user-facing async section documents context.io.async /
await / race / sleep) and the stale sched.go/sched.Task comments in io.sx.

Suite 854/0; no .ir churn (Task removal touched no snapshotted IR); migrated
examples byte-identical on aarch64-macOS + aarch64-linux. PLAN-IO-UNIFY Phases 0-5
all complete — the two parallel async stacks are now one, behind context.io.

library/modules/std/io.sx

@@ -132,14 +132,13 @@ sx_run_boxed_closure :: (arg: *void) {
 // `*Future($R)` handle. The worker must be nullary because under the fiber impl
 // the body crosses a fiber boundary, and a captured variadic pack segfaults there
 // (issue 0156 Part 2) — so any inputs are captured at the CALL SITE in the lambda
-// (`context.io.async(() -> i64 => compute(a, b))`), exactly like `sched.go`.
+// (`context.io.async(() -> (i64, !) => compute(a, b))`).
 //
 // The Future (and the completion-closure `ThunkBox`) are HEAP-allocated (not
 // returned by value): under the fiber impl the worker fills the Future AFTER
 // `async` returns, so the awaiter and the worker must share one stable object.
-// Like `sched.go`'s Task, they currently leak (bounded by the async count;
-// invisible under the default GPA). Freeing them needs join-point ownership —
-// deferred.
+// They currently leak (bounded by the async count; invisible under the default
+// GPA). Freeing them needs join-point ownership — deferred.
 //
 // ALLOCATOR-LIFETIME CONTRACT: both are allocated from the `context.allocator`
 // in force at the `async` CALL, and that allocator MUST outlive the future —
@@ -149,8 +148,7 @@ sx_run_boxed_closure :: (arg: *void) {
 // drives the worker frees the Future while it is still live (use-after-free).
 // The common case (the program-stable default GPA, or a scheduler set up under a
 // long-lived allocator) is safe. A deeper fix — `async` capturing the scheduler's
-// own long-lived allocator the way `sched.go` does — needs a protocol affordance
-// to reach it and is deferred to the convergence phase.
+// own long-lived allocator — needs a protocol affordance to reach it; deferred.
 async :: ufcs (io: Io, worker: Closure() -> ($R, !)) -> *Future($R) {
     raw := context.allocator.alloc_bytes(size_of(Future($R)));
     f : *Future($R) = xx raw;
@@ -201,9 +199,9 @@ await :: ufcs (f: *Future($R)) -> ($R, !IoErr) {
         // ONE awaiter per future (M:1): the single `park` slot records one parked
         // fiber, so a second concurrent `await` on the same pending future would
         // OVERWRITE the first awaiter's handle and orphan it forever (the worker's
-        // single `ready(f.park)` wakes only the last). Enforce loudly here, exactly
-        // as `sched.Task.wait` does — a non-null handle on a still-pending future
-        // means another fiber is already parked on it. (Fan-in over many futures —
+        // single `ready(f.park)` wakes only the last). Enforce loudly here — a
+        // non-null handle on a still-pending future means another fiber is already
+        // parked on it. (Fan-in over many futures —
         // `race` — registers ONE awaiter across SEPARATE futures, so it is fine.)
         if f.park.handle != null {
             out("io: await — future already has an awaiter (one awaiter per future in the M:1 model)\n");