iter boehm-retirement.1 (DONE 10/10): retire the transitional Boehm GC backend

Closes Gitea #4. Removes the Boehm-Demers-Weiser conservative GC
backend wholesale across six layers in one atomic iteration. After
this iter, `AllocStrategy` has two variants (`Rc`, `Bump`),
`--alloc=gc` is rejected at CLI parse with `unknown --alloc value`,
the libgc link arm is gone, and the design ledger describes RC
(canonical) + bump (raw-alloc bench-floor) as the only allocators.

Layer-by-layer summary:

  CLI surface — `crates/ail/src/main.rs`:
    `parse_alloc_strategy` arm `"gc" => Ok(AllocStrategy::Gc)`
    removed; error wording updated to `(expected `rc` or `bump`)`;
    clap-derive `value_parser = ["gc","bump","rc"]` allowlist on
    BOTH `Build` and `Run` subcommands DROPPED so that
    `parse_alloc_strategy` remains the sole gatekeeper for the
    unknown-value diagnostic (otherwise clap shadows the runtime
    diagnostic with `invalid value 'gc' for '--alloc'`, which would
    miss the milestone-pin's stderr substring check). The
    `default_value = "rc"` stays.

  Codegen — `crates/ailang-codegen/src/lib.rs`:
    `AllocStrategy::Gc` variant + `Default` derive removed (no
    caller of `AllocStrategy::default()` existed in the workspace,
    so the trait derivation was dead). `fn_name` (spec called it
    `runtime_alloc_fn` loosely; actual identifier is `fn_name`)
    drops the `Gc => "GC_malloc"` arm. `lower_workspace` and
    `lower_workspace_staticlib` defaults flip from `Gc` to `Rc`.
    In-source negative-complement codegen test (mod tests, lib.rs:3571ff)
    retargets from `AllocStrategy::Gc` to `AllocStrategy::Bump`
    (bump also doesn't emit per-type drop fns; the test's semantic
    "no drop fns under non-RC" is preserved).

  Link branch — `crates/ail/src/main.rs:2389ff`:
    The `match strategy { AllocStrategy::Gc => { ... cmd.arg("-lgc"); ... } }`
    arm and its libgc-link block are entirely gone. The surviving
    match exhausts on `Bump` and `Rc` (Rust's exhaustiveness check
    confirms; no `error[E0004]`). Staticlib-guard diagnostic
    rewritten to drop the "shared Boehm collector" phrasing while
    preserving the prefix `staticlib (swarm) artefact is RC-only`
    verbatim (the surviving `staticlib_bump_is_rejected` test
    depends on that substring).

  Test suite — 3 pure-differential e2e tests deleted
    (`gc_handles_recursive_list_construction`,
    `alloc_rc_produces_same_stdout_as_gc`,
    `alloc_rc_matches_gc_on_std_list_demo`); 9 RC-feature tests
    stripped of their `stdout_gc` build call and differential
    `assert_eq!(stdout_gc, stdout_rc, ...)` (absolute
    `assert_eq!(stdout_rc.trim(), "<n>")` pin retained as
    correctness oracle); `staticlib_gc_is_rejected` deleted; new
    milestone-pin `crates/ail/tests/boehm_retirement_pin.rs`
    asserts `ail build --alloc=gc` exits ≠ 0 with stderr containing
    `unknown --alloc value` and `\`gc\``; `examples/gc_stress.ail`
    fixture deleted (no remaining references).

    Implementer expansion (not in plan): `iter17a_local_box_alloca`
    (in `e2e.rs`) carried an IR-shape assertion against
    `@GC_malloc`-absence as the witness for non-escaping
    allocation. After the Task-2 codegen default flip, the witness
    shifts to `@ailang_rc_alloc`-absence in escape-targeted
    positions; assertion + doc-comment updated. Property
    protected ("no heap allocation in non-escaping contexts") is
    unchanged; only the named allocator shifts.

  Bench harness — `bench/run.sh` 9→6 column compaction
    (workload + bump(s) + rc(s) + rc/bump + bump RSS + rc RSS);
    gc-arm `bench_latency_implicit_gc` build call + harness
    invocation dropped from latency block; header comment reframed
    from "GC-overhead bench harness" to "RC-overhead bench
    harness"; "Decision 10's Boehm-retirement target (1.3x)"
    rewording to "RC-overhead-vs-bump bench-health regression gate".

    `bench/check.py:62` header-sentinel changes from
    `"gc(s)" in line` to `"bump(s)" in line`; column-count check
    at `:72` flips from `!= 9` to `!= 6`; per-workload field set
    drops `gc_s`/`gc_over_bump`/`gc_rss_kb`; `ARM_LABEL_TO_KEY`
    drops the `"implicit @ gc": "implicit_at_gc"` entry.
    `bench/baseline.json` regenerated via `--update-baseline`.

    Implementer note (planner-defect): `write_new_baseline`
    iterated over the *existing* baseline's metric list when
    emitting the regenerated file, so even after parser-level
    `gc_*` removal, the fallback emitted them back into the JSON.
    Scrubbed post-update; the cleaner fix (have
    `write_new_baseline` emit only keys present in
    `parsed_throughput[workload]`) is a follow-up if the script
    becomes load-bearing for further allocator changes.

  Design ledger — `design/models/rc-uniqueness.md` excises the
    `## Dual allocator — RC canonical, Boehm parity oracle`
    section and the `Boehm-Demers-Weiser conservative GC` choice
    block + rationale + trade-offs; the per-fn-alloca section
    generalises Boehm-specific language to allocator-agnostic;
    the memory-model section's `## Choice.` paragraph reframes the
    1.3× target from "Boehm-retirement gate" to "bench-health
    regression gate".

    `design/models/pipeline.md` drops the `--alloc=gc → links libgc`
    arm of the pipeline diagram and replaces it with
    `--alloc=bump → links bump-floor`; the accompanying prose
    rewrites accordingly.

    `design/contracts/scope-boundaries.md` rewrites the
    "Memory management via Boehm conservative GC" bullet to
    describe RC + per-fn-arena present-tense; the dead reference
    to `examples/gc_stress.ail.json` (file never existed; the
    fixture only ever had a `.ail` form, deleted by this iter) is
    dropped along with the `examples/std_list_stress.ail.json`
    reference whose purpose was Boehm-only soak testing.
    `:67`'s `@printf` / `@GC_malloc` parenthetical updated.

    `design/contracts/memory-model.md:232` drops the
    "leaks like the pre-Boehm era" phrase; the RC inc/dec
    instrumentation is wired up, so the "until then" conditional
    that referenced pre-Boehm is closed.

    `design/contracts/embedding-abi.md:42-44` rewrites the
    staticlib-guard prose to drop the `--alloc=gc` clause (gc is
    now a CLI-parser-level unknown-value, not a staticlib-guard
    rejection) and reframe the swarm-safety justification around
    `--alloc=bump` (leak-only bench instrument) rather than the
    historical Boehm collector.

  Honesty pin — `crates/ailang-core/tests/docs_honesty_pin.rs`
    inverts the polarity: the present-tense Boehm-anchor assertion
    on `pipeline.md` (`:116-117`) is deleted, and four
    absence-pins are added to `design_md_has_no_wunschdenken`
    against the Boehm-zombie strings `transitional Boehm`,
    `parity oracle`, `GC_malloc`, `libgc`. The
    `design_corpus()` already includes `rc-uniqueness.md` so no
    path-list change was needed for the new pins to scan.

    `crates/ailang-core/tests/design_index_pin.rs:166` drops the
    `"pre-Boehm"` token from the protected-exception comment list
    (the phrase no longer appears in `memory-model.md` after this
    iter, so the exception is dead).

  Runtime docs — `runtime/bump.c`, `runtime/rc.c`, `runtime/str.c`
    header comments scrubbed of Boehm/`GC_malloc`/`libgc`
    references. `bump.c`'s function signature description still
    documents `void *bump_malloc(size_t)` as the bench-floor
    allocator interface, but no longer cross-references libgc.

  Example fixtures — `examples/bench_latency_implicit.ail`,
    `bench_latency_explicit.ail`, `escape_local_demo.ail`,
    `reuse_as_demo.ail`, `rc_pin_recurse_implicit.ail` doc-comment
    headers scrubbed of `--alloc=gc` / Boehm references. The
    `.ail` surface (AST) is untouched in every case; round-trip
    invariant holds (`cargo test -p ailang-surface --test round_trip`
    green).

  Skill / agent prompts — `skills/audit/agents/ailang-bencher.md`
    rewritten to use an RC-vs-bump worked example pattern for the
    hypothesis-driven bench tutorial, replacing the recurring
    "RC vs Boehm under heap pressure" example.
    `skills/implement/agents/ailang-implementer.md` Decision-10 /
    Boehm references replaced with present-tense RC-commitment
    framing.

  IR snapshots — the 5 checked-in snapshots
    (`crates/ail/tests/snapshots/{hello,list,max3,sum,ws_main}.ll`)
    regenerated via `UPDATE_SNAPSHOTS=1 cargo test -p ail --test
    ir_snapshot`. Each previously contained
    `declare ptr @GC_malloc(i64)` and (for `list.ll`) a `call ptr
    @GC_malloc(...)` invocation; post-flip the snapshots contain
    `declare ptr @ailang_rc_alloc(i64)` plus the rc inc/dec runtime
    declarations.

Spec-vs-acceptance addendum (caught at orchestrator end-report,
absorbed here rather than in a follow-up spec edit): spec §6
acceptance criteria said "Boehm-grep returns matches ONLY in
docs_honesty_pin.rs". The plan itself prescribed historical Boehm
references in 3 additional files: (a) the new milestone-pin
`boehm_retirement_pin.rs` (must literally invoke `--alloc=gc` to
assert its rejection), (b) `embed_staticlib_alloc_guard.rs` file
doc-comment historical note ("`--alloc=gc` no longer exists as a
CLI value"), (c) `embedding-abi.md:44-45` contract historical
clause ("see the Boehm-retirement iter"). All three are
prescribed; the spec's grep wording was too narrow. The four
absence-pins in `docs_honesty_pin.rs` catch the actual zombies
(Boehm-narrative re-emerging in the design ledger), which is the
substantive intent the spec was aiming at — the four extra
documented-by-design exceptions are the cost of having an
explicit milestone-pin and contract-level historical anchors.

Net delta:
  - 32 files modified, 2 new (boehm_retirement_pin.rs + stats),
    1 deleted (gc_stress.ail);
  - workspace tests: every binary `0 failed`. Pass-count delta:
    -3 net (4 e2e tests deleted, 1 new milestone-pin test added);
  - boehm-grep state: hits only in the four by-design exceptions
    documented above;
  - `bench/check.py` exit 0 against regenerated baseline;
  - CLI must-fail fixture: `ail build --alloc=gc examples/hello.ail`
    exits non-zero with stderr containing `unknown --alloc value`
    and `\`gc\``;
  - design ledger present-tense honest (Boehm-narrative gone from
    `rc-uniqueness.md` + `pipeline.md`; the few historical
    references in `embedding-abi.md` / `boehm_retirement_pin.rs` /
    `embed_staticlib_alloc_guard.rs` are explicit milestone-pins
    or contract anchors, not silent ledger residue).

Bench measurement variance noted: closure-chain and hof-pipeline
are ±1-5% jittery between runs; one regeneration flagged 2
metrics as `regressed` before a second run returned 0. The
captured baseline is within self-comparison range. Existing
per-metric tolerances absorb the jitter.

Stats file:
`bench/orchestrator-stats/2026-05-20-iter-boehm-retirement.1.json`.

closes #4

crates/ail/src/main.rs

@@ -133,17 +133,14 @@ enum Cmd {
         /// Optimization (e.g. `-O2`); default `-O0` for debuggability.
         #[arg(long, default_value = "-O0")]
         opt: String,
-        /// Heap allocator. `rc` (default, canonical) routes through
-        /// `runtime/rc.c`'s `@ailang_rc_alloc` (libc-malloc backing +
-        /// 8-byte refcount header) with `ailang_rc_inc`/`_dec`
-        /// instrumentation emitted by codegen; this is the runtime
-        /// AILang's memory model (RC + uniqueness) is
-        /// designed for. `gc` retains the Boehm conservative GC path
-        /// (`@GC_malloc`, libgc); it is kept as a differential parity
-        /// oracle for codegen diagnosis (the transitional dual-allocator). `bump` is a
-        /// bench-only no-free stub from `runtime/bump.c` — it leaks
-        /// every allocation by design.
-        #[arg(long, default_value = "rc", value_parser = ["gc", "bump", "rc"])]
+        /// Allocator backend. `rc` is the canonical production
+        /// allocator (reference counting + uniqueness inference);
+        /// codegen routes allocation through `runtime/rc.c`'s
+        /// `@ailang_rc_alloc` with `ailang_rc_inc`/`_dec` instrumentation.
+        /// `bump` is a raw-alloc bench-floor (no free; leak-tolerant;
+        /// `runtime/bump.c`'s 256MB arena); bench-only, not a
+        /// production target.
+        #[arg(long, default_value = "rc")]
         alloc: String,
         /// Output shape. `exe` (default): whole-program executable
         /// (requires an entry `main`). `staticlib`: a relocatable
@@ -164,7 +161,7 @@ enum Cmd {
         #[arg(long, default_value = "-O0")]
         opt: String,
         /// Heap allocator. See `build --alloc` for details. Default `rc`.
-        #[arg(long, default_value = "rc", value_parser = ["gc", "bump", "rc"])]
+        #[arg(long, default_value = "rc")]
         alloc: String,
         /// Args passed through to the compiled program.
         #[arg(last = true)]
@@ -2140,11 +2137,10 @@ fn render_workspace_diff_text(r: &WorkspaceDiffReport) -> String {
 
 fn parse_alloc_strategy(s: &str) -> Result<ailang_codegen::AllocStrategy> {
     match s {
-        "gc" => Ok(ailang_codegen::AllocStrategy::Gc),
         "bump" => Ok(ailang_codegen::AllocStrategy::Bump),
         "rc" => Ok(ailang_codegen::AllocStrategy::Rc),
         other => anyhow::bail!(
-            "unknown --alloc value `{other}` (expected `gc`, `bump`, or `rc`)"
+            "unknown --alloc value `{other}` (expected `rc` or `bump`)"
         ),
     }
 }
@@ -2186,9 +2182,9 @@ fn locate_bump_runtime() -> Result<PathBuf> {
 
 /// Locate the workspace-root `runtime/rc.c` file relative to the
 /// `ail` binary, mirroring [`locate_bump_runtime`]. The `--alloc=rc`
-/// path (Iter 18b) compiles this stub and links it instead of `-lgc`;
-/// it supplies `ailang_rc_alloc` / `ailang_rc_inc` / `ailang_rc_dec`
-/// against libc malloc/free.
+/// path compiles this stub for the canonical RC build; it supplies
+/// `ailang_rc_alloc` / `ailang_rc_inc` / `ailang_rc_dec` against
+/// libc malloc/free.
 fn locate_rc_runtime() -> Result<PathBuf> {
     let candidates = [
         std::env::current_exe().ok(),
@@ -2257,13 +2253,12 @@ fn locate_str_runtime() -> Result<PathBuf> {
 /// only known after typecheck). The lifted workspace then goes to
 /// codegen unchanged.
 ///
-/// Bench iter: `alloc` selects the heap allocator the emitted IR
-/// targets. Default `Gc` keeps the entire pipeline (IR text, link
-/// command) byte-identical to pre-bench. `Bump` declares
-/// `@bump_malloc` instead of `@GC_malloc` and links `runtime/bump.c`
-/// in lieu of `-lgc`. `Rc` (Iter 18b) declares `@ailang_rc_alloc`
-/// instead and links `runtime/rc.c` — RC runtime, alloc-only — Iter
-/// 18b plumbing; inc/dec instrumentation arrives in 18c.
+/// `alloc` selects the heap allocator the emitted IR targets.
+/// Default `Rc` is the canonical production path: declares
+/// `@ailang_rc_alloc` (with `ailang_rc_inc` / `ailang_rc_dec`
+/// instrumentation) and links `runtime/rc.c`. `Bump` declares
+/// `@bump_malloc` for the bump bench-floor; links
+/// `runtime/bump.c` statically.
 fn build_to(
     path: &Path,
     out: Option<PathBuf>,
@@ -2362,12 +2357,11 @@ fn build_to(
     // `ailang_int_to_str` / `ailang_float_to_str` call
     // `ailang_rc_alloc` defined in rc.c; the weak extern declaration
     // in str.c (iter hs.3) resolves to the strong definition here.
-    // Under --alloc=gc / --alloc=bump the alloc strategy still
-    // governs ADT allocation (GC_malloc / bump_malloc); rc.c
-    // provides the heap-Str primitives in parallel. clang -O2
-    // dead-strips the rc.c symbols when no caller exists in the
-    // final binary, so the link-time overhead under gc / bump is
-    // negligible.
+    // Under --alloc=bump the alloc strategy still governs ADT
+    // allocation (bump_malloc); rc.c provides the heap-Str primitives
+    // in parallel. clang -O2 dead-strips the rc.c symbols when no
+    // caller exists in the final binary, so the link-time overhead
+    // under bump is negligible.
     let rc_src = locate_rc_runtime()?;
     let rc_obj = tmpdir.join("rc.o");
     let cstatus = std::process::Command::new("clang")
@@ -2386,17 +2380,10 @@ fn build_to(
     }
     clang.arg(&rc_obj);
     match alloc {
-        ailang_codegen::AllocStrategy::Gc => {
-            // Boehm conservative GC (the transitional dual-allocator). The lowered
-            // IR calls @GC_malloc; libgc supplies it. Pthread/dl are
-            // pulled in transitively via libgc.so on Linux, so a single
-            // -lgc suffices.
-            clang.arg("-lgc");
-        }
         ailang_codegen::AllocStrategy::Bump => {
-            // Bench iter: link the no-free arena stub from
-            // `runtime/bump.c` instead of libgc. We compile the stub
-            // inline at -O2 (its body is small, the .o is cached at
+            // Link the no-free arena stub from `runtime/bump.c` for
+            // the bump bench-floor build. We compile the stub inline
+            // at -O2 (its body is small, the .o is cached at
             // <tmpdir>/bump.o per build invocation; no global cache
             // because the bench harness rebuilds binaries top-to-bottom
             // anyway).
@@ -2422,7 +2409,7 @@ fn build_to(
             // rc.c compile-and-link hoisted to the
             // unconditional path above. `--alloc=rc` is still a
             // valid CLI flag — it drives codegen's
-            // `@ailang_rc_alloc`-vs-`@GC_malloc` selection in the IR
+            // `@ailang_rc_alloc`-vs-`@bump_malloc` selection in the IR
             // header — so the match arm is retained, but its body
             // is empty (no rc-specific linking work remains).
         }
@@ -2494,8 +2481,8 @@ fn build_staticlib(
     }
     if !matches!(alloc, ailang_codegen::AllocStrategy::Rc) {
         anyhow::bail!(
-            "staticlib (swarm) artefact is RC-only — `--alloc=gc` links the \
-             shared Boehm collector, which is not swarm-safe; use `--alloc=rc`"
+            "staticlib (swarm) artefact is RC-only — `--alloc=bump` links a \
+             leak-only bench instrument, not swarm-safe; use `--alloc=rc`"
         );
     }
     let ir = ailang_codegen::lower_workspace_staticlib_with_alloc(&ws, alloc)?;