fibers B1.2: Io capability + context.io + blocking impl + Future/async/await/cancel

Threads an `Io` capability onto `Context` exactly like `Allocator`: a
`protocol #inline` whose process-wide default is a stateless `CBlockingIo`
(the mirror of `CAllocator`), installed in `__sx_default_context`.

Library (library/modules/std):
- core.sx: `Io` protocol (spawn_raw / suspend_raw / ready / poll / now_ms /
  arm_timer) + `SpawnOpts` / `PinTarget` / `ParkToken`; `Context` gains an
  `io: Io` field LAST (allocator stays index 0, data stays index 1).
- io.sx (new): `CBlockingIo` + `impl Io` (blocking M:1 semantics — now_ms is
  a real monotonic clock, the rest are no-ops/0; suspend never called);
  `Future($R)` { value; state: FutureState; err: IoErr; park; task; canceled:
  Atomic(bool) } with `Value :: R`; the async ergonomic layer
  `async` / `async_void` / `await` (value-carrying `(R, !IoErr)`) / `cancel`.
  Built with the verified `= ---` + field-assign + `Closure(..$args) -> $R` +
  `..$args` idiom (NON-void $R only — Future(void) is deferred per issue 0150).
- std.sx: re-export the Io surface + the io.sx tail.

Compiler (src/ir):
- protocol.zig `emitDefaultContextGlobal` + comptime_vm.zig
  `materializeDefaultContext`: both materializers of `__sx_default_context`
  now build the inline CBlockingIo->Io vtable (7 words) at the new field.
- stmt.zig `lowerPush`: `push Context.{...}` now INHERITS omitted fields from
  the ambient context (seed the slot from current_ctx_ref, overwrite only the
  literal's named fields) — correct capability-bag semantics, so the partial
  `push Context.{ allocator = X }` sites don't zero a null `io` vtable.
- protocols.zig + lower.zig + error_analysis.zig: record protocol-impl method
  names so the "declared `!` but never errors" lint skips a conforming impl
  whose `!` is dictated by the protocol contract (e.g. Io.suspend_raw).

37 `.ir` snapshots regenerated: layout-only (the Context type now carries the
Io field, shifting type-table numbering); no stdout/stderr/exit changes.

The blocking Io + now_ms + Future/async work when `async` is called with the
receiver passed explicitly; the user-facing UFCS form `context.io.async(...)`
is blocked on a separate UFCS generic-inference bug (filed next).

Suite: 726 ran, 0 failed.

src/ir/lower/protocol.zig

@@ -254,6 +254,8 @@ pub fn emitDefaultContextGlobal(self: *Lowering) void {
     const ctx_ty = tbl.findByName(ctx_name_id) orelse return;
     if (tbl.findByName(tbl.internString("Allocator")) == null) return;
     if (tbl.findByName(tbl.internString("CAllocator")) == null) return;
+    if (tbl.findByName(tbl.internString("Io")) == null) return;
+    if (tbl.findByName(tbl.internString("CBlockingIo")) == null) return;
 
     // Force the CAllocator → Allocator thunks to exist so we can
     // reference them by FuncId in the static initializer.
@@ -267,10 +269,20 @@ pub fn emitDefaultContextGlobal(self: *Lowering) void {
     alloc_fields[1] = .{ .func_ref = thunks[0] };
     alloc_fields[2] = .{ .func_ref = thunks[1] };
 
-    // Context value: { allocator: Allocator, data: *void }
-    const ctx_fields = self.alloc.alloc(inst_mod.ConstantValue, 2) catch return;
+    // Force the CBlockingIo → Io thunks to exist. The Io protocol has 6
+    // methods, so the inline value is { ctx, fn0..fn5 } — 7 pointer words.
+    const io_thunks = self.getOrCreateThunks("Io", "CBlockingIo");
+    if (io_thunks.len < 6) return;
+    const io_fields = self.alloc.alloc(inst_mod.ConstantValue, io_thunks.len + 1) catch return;
+    io_fields[0] = .null_val; // CBlockingIo is stateless → null receiver.
+    for (io_thunks, 0..) |fid, i| io_fields[i + 1] = .{ .func_ref = fid };
+
+    // Context value: { allocator: Allocator, data: *void, io: Io }.
+    // `data` keeps index 1; `io` is appended last.
+    const ctx_fields = self.alloc.alloc(inst_mod.ConstantValue, 3) catch return;
     ctx_fields[0] = .{ .aggregate = alloc_fields };
     ctx_fields[1] = .null_val;
+    ctx_fields[2] = .{ .aggregate = io_fields };
 
     const global_name = "__sx_default_context";
     const global_name_id = tbl.internString(global_name);