iter remove-mut-var-assign.1: atomic removal of mut/var/assign

mut/var/assign removed from AILang entirely and atomically. Deleted:
Term::Mut/Term::Assign/struct MutVar; the three Form-A keywords +
parse_mut/parse_assign + grammar EBNF; the 4 mut CheckError variants;
the mut_scope_stack synth threading (param dropped from synth + every
internal/external/test caller); the two lower_term arms; and every
exhaustive no-_ Term::Mut/Term::Assign match arm across 17 source
files — cut in lockstep with DESIGN.md, fixtures, the drift trio,
carve-out and roadmap so the schema is honest at every commit. No
catch-all wildcard introduced (verified). loop/recur + let/if are
the surviving forms.

The shared codegen alloca machinery survives (loop reuses it):
mut_var_allocas renamed binder_allocas (representation-only, loop
codegen byte-identical) and the shared Term::Lam escape guard
simplified to !loop_stack.is_empty() with the loop half
(LoopBinderCapturedByLambda) byte-equivalent. Feature-acceptance
applied inverted: the removed feature fails clause 2 (redundant)
and clause 3 (IS the iterated-mutable-state bug class).

Behaviour preservation is executable: mut_counter/mut_sum_floats
still print 55 after the faithful let/if rewrite. The removal is
made executable by the new mut_removed_pin.rs (4 must-fail pins).
Independent verification: cargo test --workspace 605/0, zero
residual mut symbols in any crate source, loop/recur non-regression
all green (55 / 500000500000 / infinite-compiles / the
lambda_capturing_loop_binder pin), roundtrip_cli PASS.

One DONE_WITH_CONCERNS: a 4th recurrence of the recon-undercount
class (in-source mod tests + a drift-pin fn + 5 orphaned mut
.ail.json carve-outs + a non-enumerated E0599); all resolved within
implementer remit, no behaviour change. Milestone-close audit then
fieldtest remain.

spec docs/specs/2026-05-18-remove-mut-var-assign.md (grounding PASS)
plan docs/plans/remove-mut-var-assign.1.md

crates/ailang-check/src/linearity.rs

@@ -592,23 +592,6 @@ impl<'a> Checker<'a> {
                 // standard position rules.
                 self.walk(body, pos);
             }
-            // Iter mut.1: mut-vars are alloca-resident scalars (Int /
-            // Float / Bool / Unit per spec §"Iteration mut.1") — they
-            // are not RC-managed and do not participate in the
-            // linearity analysis. Walk children defensively so any
-            // RC-managed value referenced inside an init or the body
-            // is still tracked.
-            Term::Mut { vars, body } => {
-                for v in vars {
-                    self.walk(&v.init, Position::Consume);
-                }
-                self.walk(body, pos);
-            }
-            Term::Assign { value, .. } => {
-                // The assigned `name` is a mut-var (alloca slot, not
-                // a tracked binder). Walk the `value` normally.
-                self.walk(value, Position::Consume);
-            }
             Term::Loop { binders, body } => {
                 for b in binders {
                     self.walk(&b.init, Position::Consume);
@@ -804,8 +787,6 @@ fn make_reuse_as_source_not_bare_var(def: &str, source: &Term, body: &Term) -> D
         Term::Seq { .. } => "seq",
         Term::Clone { .. } => "clone",
         Term::ReuseAs { .. } => "reuse-as",
-        Term::Mut { .. } => "mut",
-        Term::Assign { .. } => "assign",
         Term::Loop { .. } => "loop",
         Term::Recur { .. } => "recur",
     };
@@ -933,20 +914,6 @@ fn any_sub_binder_consumed_for(
             any_sub_binder_consumed_for(source, pname, uniq, def_name, ctors)
                 || any_sub_binder_consumed_for(body, pname, uniq, def_name, ctors)
         }
-        // Iter mut.1: mut-vars are scalar (Int/Float/Bool/Unit) and
-        // do not participate in the consume-tracking heuristic; the
-        // surrounding analysis only cares about heap-typed param
-        // consumption. Recurse into children defensively so any
-        // genuine consume-of-`pname` inside a var init / body /
-        // assign value still surfaces.
-        Term::Mut { vars, body } => {
-            vars.iter().any(|v| {
-                any_sub_binder_consumed_for(&v.init, pname, uniq, def_name, ctors)
-            }) || any_sub_binder_consumed_for(body, pname, uniq, def_name, ctors)
-        }
-        Term::Assign { value, .. } => {
-            any_sub_binder_consumed_for(value, pname, uniq, def_name, ctors)
-        }
         Term::Loop { binders, body } => {
             binders.iter().any(|b| {
                 any_sub_binder_consumed_for(&b.init, pname, uniq, def_name, ctors)