feat(borrow): flow-sensitive escape via outer = &y (CORE-01 pt3 Slice B, Refs #177)

[hyperpolymath]

Summary

CORE-01 Phase 3 Slice B — flow-sensitive escape via re-assignment. let mut r = &x; r = &y now correctly updates the borrow graph: the old held borrow on x is released and the (r → new_borrow) entry is re-bound to the freshly-created borrow on y. The NLL last-use machinery from Slice A (#335) now sees the current referent after re-assignment, not the stale original.

Before this PR (post-Slice-A behaviour):

let mut x = 1;
let mut y = 2;
let mut r = &x;
let z = *r;
r = &y;
x = 10;       // ← MoveWhileBorrowed: the &x held by r was never released
*r + x + z

After this PR: x = 10 is Ok, *r reads through the new borrow on y.

Mechanics in lib/borrow.ml StmtAssign

When LHS is a ref-binder symbol that already holds a borrow AND RHS is a direct &p/&mut p:

1. Pre-release the old held borrow (via end_borrow) and remove the stale entry from ref_bindings before checking the RHS. The pre-release order matters for the same-target reborrow case (r = &mut x while r already holds &mut x): post-release ordering would trip ConflictingBorrow on the about-to-be-replaced exclusive borrow at record_borrow time, which is a sequential-modelling artefact, not a real conflict.
2. Check the RHS — record_borrow adds the new borrow to state.borrows the usual way.
3. After RHS-check, look up the freshly-created borrow on the new target place and bind it into ref_bindings as (binder_sym, new_borrow) — the symmetric assignment-side of record_ref_binding's let-graph contract.

Tests (E2E Borrow Graph, +3)

Fixture	Direction	Expected	Distinguishes
slice_b_outer_assign_releases_old.affine	positive	Ok	Without pre-release, x = 10 still fails MoveWhileBorrowed
slice_b_nll_expires_new.affine	positive	Ok	Without re-bind, NLL expires the wrong borrow, y = 10 fails
slice_b_new_borrow_still_protects.affine	anti-regression	MoveWhileBorrowed	Confirms new borrow is tracked, not silently dropped

Anti-regression sweep

All existing borrow / quantity / linear-arrow fixtures audited and remain green by construction: the new path only fires when LHS is a ref-binder AND RHS is a direct &p/&mut p. Every other StmtAssign shape (literal RHS, function-call RHS, non-ref-binder LHS, deref LHS) takes the pre-existing code path unchanged.

Scope of this PR

This completes the original "flow-sensitive escape" residual from CORE-01 pt3.

Deferred (Slices C–D residual):

• Reborrow through indirection: r = some_other_ref_var (RHS not a direct &place) still leaves the ref-binding stale. Same limitation as record_ref_binding's let-graph path; would need symmetric ref-to-ref binding for both let and assign.
• Slice C — origin/region variables (Polonius surface) + loan-live-at-point dataflow across CFG joins for ExprHandle/ExprTry/loops. Needs an ADR for the type-system shape before implementation.
• Slice D — tighter quantity-checker integration for captured linears.

Docs

• STATE.a2ml borrow-checker → phase-3-parts-1-3-Slices-A-and-B-landed
• CAPABILITY-MATRIX.adoc borrow-checker row records Slice B
• TECH-DEBT.adoc CORE-01 row records Slice B + narrows residual to Slices C–D

Test plan

• CI build (opam exec -- dune build) green
• CI lint + Run tests (opam exec -- dune runtest) — E2E Borrow Graph count +3 (the 3 new Slice B cases), all green
• CI Run codegen WASM tests green — full stdlib AOT exercises the corpus
• CI Check formatting green

Local-build caveat: container has no OCaml toolchain, so dune build / dune runtest were not run locally. CI is the source of truth.

Refs #177

---

Generated by Claude Code