[Repo Assist] Fix #323: Promote mutable variables captured by closures to ref cells in QuotationSimplifier

[github-actions]

🤖 This PR was created by Repo Assist, an automated AI assistant. Fixes #323.

Problem

When a let mutable v = ... variable is captured by a lambda in a quotation used by a generated type provider, the TPSDK IL emitter copies the variable's value into a closure field at lambda-creation time. Mutations inside the closure do not propagate back to the outer scope (and vice versa), causing incorrect runtime behaviour:

let mutable x = 0
let f a =
    x <- x + a       // modifies x, but changes are lost at lambda boundary
    fun b ->
        x <- x + b
        fun c ->
            x <- x + c
let g = f 1
let x0 = x           // was 0, should be 1
let h = g 2
let x1 = x           // was 1, should be 3
h 3
x0, x1, x            // was (0, 1, 3), should be (1, 3, 6)
```

This is the issue identified in #323, which also included a `[(Fact(Skip = "Need to replace captured mutables with refs"))]` test that was never passing.

## Root Cause

The `QuotationSimplifier` transforms source quotations into a form that the TPSDK IL emitter can handle. It had no special handling for `let mutable v` bindings whose variable `v` is a free variable of an inner lambda. The generic `ShapeCombinationUnchecked` fallthrough passed these through unchanged, relying on the downstream emitter to handle mutable capture — but `emitLambda` copies values by value into closure fields and has no mechanism to share mutable state.

## Fix

Added two helper functions to `QuotationSimplifier`:

1. **`isCapturedByLambda (v: Var) (expr: Expr) → bool`** — walks `expr` looking for any `ShapeLambda` where `v` appears as a free variable (via `GetFreeVars()`).

2. **`promoteMutableToRef (v: Var) (initExpr: Expr) (body: Expr) → Expr`** — rewrites `let mutable v = initExpr in body` as:
   ```
   let v_ref = ref initExpr in body'
   ```
   where `body'` replaces every `Var(v)` (read) with `!v_ref` and every `VarSet(v, e)` (write) with `v_ref := e'`. This matches how the F# compiler itself handles mutable capture by closures.

A new `Let` case is added in `simplifyExpr` that fires when `v.IsMutable && isCapturedByLambda v bexpr`, triggering the promotion before falling through to the generic cases.

## Trade-offs

- The transformation adds a ref-cell indirection for every mutable variable that is captured by a closure. This is a one-time cost at TP design-time (quotation simplification), not at user runtime.
- Mutable variables that are **not** captured by lambdas are unaffected — they continue to use `VarSet` / direct `stloc` as before.
- The fix is applied unconditionally (not gated on `isGenerated`). For erased TPs the F# compiler handles mutable capture itself, but the transformed quotation (using ref cells) is semantically equivalent, so no regression.

## Test Status

The previously-skipped test `TPSDK.GeneratedCodeTests.lambdas - failing` now passes. Full test suite: **103 passed, 0 failed** on net8.0.

```
Test Run Successful.
Total tests: 103
     Passed: 103
 Total time: 8.77 Seconds

Generated by Repo Assist

To install this agentic workflow, run

gh aw add githubnext/agentics/workflows/repo-assist.md@69c1ee19e39e6aaba35519aafefb5cbf314de323