`Stdio` (fd 0/1/2, direct), `effect Console` + `StdioConsole` (the dispatched,
config-selectable face), six capability cells, a run-gated corpus app, and a
section in the book. No Rust, no new intrinsic, no floor change:
`write_bytes`/`read_bytes` have been in `Floor.ckh` since the IO widening.

WHY NOW. `tests/corpus/ml_tictactoe` had hand-written a console — a `say`, a
byte writer, and a buffered fd-0 reader with its own two-word control block —
which is the standard library admitting it had none. And nothing in this repo
RAN a program that read fd 0 at all: that app is size-pinned, never executed, so
the reader every interactive CkLang program needs was unproven at runtime.

THREE CONSTRAINTS WROTE THE API, and each is a gap showing through rather than
a preference (plan.md §4g carries the long form):

  * no `Alloc` — it is condemned and the self-hosted stdlib excises it, so the
    three units hold ZERO condemned sites and port unchanged. The price is
    visible: `line` is two writes because `s ++ "\n"` mmaps, and integers go
    through `int_into(scratch, n)` because `Prelude::show_i64` mmaps twice and
    releases one of them;
  * end of input is `-1` — `String` is structurally non-empty and `match` over
    a union does not lower, so it cannot be `""`, `Option`, or `Result`;
  * every `Console` operation returns `Unit` — binding an effect operation's
    result in a free `fn` leaves the frame slot unresolved and E0760 shuts the
    door, so `read_line` answers through `ctl` and `Stdio::last_len` reads it.

RATCHETS, all three moved deliberately:

  * `CELL_COUNT` 440 -> 446;
  * `BROKEN_CELL_COUNT` 43 -> 44 —
    `a_floor_load_in_a_test_fn_body_does_not_lower`, found building this.
    `Floor::load` written directly in a `test fn` body reaches codegen
    unresolved while the `Floor::store` beside it lowers and the same load
    through a cross-module `fn` lowers on both entries, so it is which bodies
    the test entry stamps, not the leaf. It blocked nothing;
  * `CONDEMNED_ALLOC_SITES_COUNT` 380 -> 394, seven rows, OWNER-BLESSED. The
    rule's own remedy is "an unavoidable site is an owner decision, not a table
    edit" — it was asked and granted. `read(2)` writes into caller memory and
    `Alloc::os_acquire` is CkLang's only way to obtain a writable `Region`;
    `Floor::mmap` reaches the same syscall past the counter and was NOT used.
    All 14 are in what exercises the console, none in the console.

MEASURED AND SAID OUT LOUD: the bundled test mock is declared, not dispatched
to. A `test fn` calling `Console::line` reaches `StdioConsole` and the bytes
land on fd 1; `Log::info` behaves identically. `Log.ckh`'s claim that the test
path resolves the mock automatically does not hold at that position, and
`Console.ckh` states what is true rather than repeating it.

Gates: 4 legs green, integration sweep 251 passed / 1 known-red (the standing
`lib.rs` R3), fmt and clippy clean.

@@ -193,6 +214,7 @@ const CONDEMNED_ALLOC_SITES: &[(&str, usize)] = &[
     ("tests/corpus_test_run/bytes_roundtrip/Main.ck", 2),
     ("tests/corpus_test_run/clock_tick/Main.ck", 1),
     ("tests/corpus_test_run/freestanding_mem/Main.ck", 3),
+    ("tests/corpus_test_run/console_io/Main.ck", 2),

@@ -562,0 +579,4 @@
+// not the leaf. Pinned by `a_floor_load_in_a_test_fn_body_does_not_lower`. It
+// blocks nothing: the console reads its control block through
+// `Stdio::last_len`, a cross-module call that was the better surface anyway.
+const BROKEN_CELL_COUNT: usize = 44;

@@ -0,0 +31,4 @@
+fn out(s: String) -> Unit = write_str(1::i64, s)
+
+// fd 2.
+fn err(s: String) -> Unit = write_str(2::i64, s)