source: scrub iter-code / Decision-N residue from inline comments

Follow-up to bcd4181: the remaining ~530 inline `//` and `///`
comments still carrying opaque shorthand are now reformulated to
their content phrases. The only surviving `iter-<code>` reference
in source is the literal filename
`docs/journals/2026-05-13-iter-mq.3.md` (a real journal file).

Sweep covered:
  - `// Iter X.Y: <text>` prefixes (Iter 13a / 14a / 14e / 15g-aux /
    16b.x / 16d / 16e / 18b / 18c.x / 18d.x / 18e / 18g.x / 19a /
    19a.1 / 19b / 20a / 20f / 22-floats.x / 22b.x / 22c / 23.x /
    24.1 / cli-diag-human / hs.x / str-concat / etc.) — fully
    removed; the descriptive text that followed each prefix stays.
  - `// (Decision N)` and `per Decision N` and `Decision N axis 3` —
    replaced with the content phrase plus the relevant contract
    file (`design/contracts/tail-calls.md` for Decision 8,
    `design/contracts/memory-model.md` for Decision 10,
    `design/contracts/typeclasses.md` and `design/models/typeclasses.md`
    for Decision 11, `design/contracts/authoring-surface.md` for
    Decision 6, "the transitional dual-allocator" for Decision 9,
    "Effect prose" for Decision 3).
  - `// mq.X / mq.X (Task N) / mq.X journal / mq.X invariant` ->
    "the canonical-class-form rule / Class-class repurpose /
    method-dispatch-refactor journal / canonical-class-form
    invariant".
  - `// ct.X / ct.X (canonical-type-names) / ct.1.5a + ctt.2 /
    ct.2 Task N` -> "the canonical-form rule for type references /
    the canonical-form normalisation step / canonical-type-lookup
    refactor".
  - `// eob.X` -> "heap-Str-ABI" / "the Str carve-out".
  - `// rpe.X` -> "the per-type-print-op retirement".
  - `// post-mq.X / Pre-ct.X / pre-mq.X` -> "post-canonical-class-form" /
    "Pre-canonical-type-form" etc.
  - `/// Iter X regression: / /// Iter X.Y: / /// Iter A arm-close /
    /// Iter ct.4 (...): / /// Iter rpe.1 ...` -> descriptive
    phrases.

The journal filename in `crates/ailang-core/src/workspace.rs:573`
stays verbatim because it points at an actual file under
`docs/journals/`.

Tests: full `cargo test --workspace` green (80/80 test-result blocks
clean, no FAILED line). design_index_pin 5/5 + docs_honesty_pin 5/5
gating tests pass.

crates/ailang-surface/src/print.rs

@@ -44,7 +44,7 @@ pub fn term_to_form_a(t: &Term) -> String {
     out
 }
 
-/// Iter 19a: render a [`Type`] as form-A. Used by diagnostics that want
+/// render a [`Type`] as form-A. Used by diagnostics that want
 /// to suggest a relaxed signature (e.g. `over-strict-mode` shows the
 /// `(fn-type ...)` with `(borrow T)` in place of `(own T)`). Output is
 /// the same shape that appears as the `type` slot of a `(fn ...)` def.
@@ -123,7 +123,7 @@ fn write_type_def(out: &mut String, td: &TypeDef, level: usize) {
         out.push('\n');
         write_ctor(out, c, level + 1);
     }
-    // Iter 18e: `(drop-iterative)` annotation. Printed last (after
+    // `(drop-iterative)` annotation. Printed last (after
     // every ctor) so the canonical form lands consistent with the
     // design/contracts/data-model.md example. Omitted when `drop_iterative == false`.
     if td.drop_iterative {
@@ -163,7 +163,7 @@ fn write_fn_def(out: &mut String, fd: &FnDef, level: usize) {
         write_string_lit(out, export);
         out.push(')');
     }
-    // Iter 19b: emit one `(suppress ...)` clause per entry, after the
+    // emit one `(suppress ...)` clause per entry, after the
     // doc string and before the type. Round-trip stable: parser
     // re-reads each clause back into [`FnDef::suppress`].
     for s in &fd.suppress {
@@ -191,7 +191,7 @@ fn write_fn_def(out: &mut String, fd: &FnDef, level: usize) {
     out.push(')');
 }
 
-/// Iter 19b: print one `(suppress (code "<c>") (because "<r>"))`
+/// print one `(suppress (code "<c>") (because "<r>"))`
 /// clause. Indentation matches the rest of the fn-def (one level
 /// deeper than the `(fn ...)` head).
 fn write_suppress(out: &mut String, s: &Suppress, level: usize) {
@@ -323,7 +323,7 @@ fn write_instance_method(out: &mut String, m: &InstanceMethod, level: usize) {
 
 // ---- types ----------------------------------------------------------------
 
-/// Iter 18a: print one fn-type param/ret slot, wrapping with
+/// print one fn-type param/ret slot, wrapping with
 /// `(borrow ...)` or `(own ...)` when the slot has an explicit
 /// mode. `Implicit` is printed bare so pre-18a fixtures round-trip
 /// unchanged.
@@ -343,7 +343,7 @@ fn write_fn_type_slot(out: &mut String, t: &Type, mode: ParamMode) {
     }
 }
 
-/// Iter 22b.4a.4.5: print one `(constraint <Class> <type>)` pair, used
+/// print one `(constraint <Class> <type>)` pair, used
 /// inside the optional `(constraints …)` clause of a `(forall …)`. The
 /// clause itself is omitted entirely when `Type::Forall.constraints` is
 /// empty so pre-22b.2 forall fixtures stay bit-identical.
@@ -422,7 +422,7 @@ fn write_term(out: &mut String, t: &Term, level: usize) {
         Term::Lit { lit } => write_lit(out, lit),
         Term::Var { name } => out.push_str(name),
         Term::App { callee, args, tail } => {
-            // Iter 14e: `tail-app` is the form for `App { tail: true }`;
+            // `tail-app` is the form for `App { tail: true }`;
             // otherwise the regular `app` head is used. Both productions
             // are positional analogues of each other — only the head
             // keyword differs.
@@ -469,7 +469,7 @@ fn write_term(out: &mut String, t: &Term, level: usize) {
             out.push(')');
         }
         Term::Do { op, args, tail } => {
-            // Iter 14e: `tail-do` mirrors `tail-app` for effect ops.
+            // `tail-do` mirrors `tail-app` for effect ops.
             out.push_str(if *tail { "(tail-do " } else { "(do " });
             out.push_str(op);
             for a in args {
@@ -537,7 +537,7 @@ fn write_term(out: &mut String, t: &Term, level: usize) {
             out.push(')');
         }
         Term::Clone { value } => {
-            // Iter 18c.1: print as `(clone <inner>)`. The wrapper is
+            // print as `(clone <inner>)`. The wrapper is
             // identity at typecheck/codegen in 18c.1; only authored
             // intent is recorded for the future inc/dec emission pass.
             out.push_str("(clone ");
@@ -545,7 +545,7 @@ fn write_term(out: &mut String, t: &Term, level: usize) {
             out.push(')');
         }
         Term::ReuseAs { source, body } => {
-            // Iter 18d.1: print as `(reuse-as <source> <body>)`. The
+            // print as `(reuse-as <source> <body>)`. The
             // wrapper is identity at codegen in 18d.1 (the `body` is
             // lowered, the `source` is dropped); 18d.2 will lower this
             // as in-place rewrite under `--alloc=rc`.
@@ -812,7 +812,7 @@ mod tests {
         round_trip(m, "minimal_instance");
     }
 
-    /// Iter 22-floats.2 RED: `lex(print(L)) == L` round-trip property
+    /// `lex(print(L)) == L` round-trip property
     /// for Float literals. Six representative bit patterns:
     /// `1.5`, `0.0`, `-0.0`, `10.0`, `-0.375`, `1e10`. The round-trip
     /// uses the existing `round_trip(Module, &str)` helper, which