Iter 16b.5: LetRec name as value (in_term only) via eta-Lam wrapper

Drops the direct-call-only restriction on the LetRec name when it
appears in `in_term`. No new ABI: the lift wraps the in-term in
`(let f (lam P (app f$lr_N P CAPTURES)) in_term')` so codegen's
existing Iter-8b closure-pair machinery handles it. Body-position
name-as-value still rejected (deferred — eta-of-self is harder).

- desugar.rs / lift.rs: split find_non_callee_use into body
  (panic) and in_term (wrap).
- examples/local_rec_as_value.{ailx,ail.json}: no-capture path
  (factorial passed to apply5 → 120).
- examples/local_rec_as_value_capture.{ailx,ail.json}: capture
  path; lifted fn has captures, eta-Lam picks them up via 8b.
- e2e + desugar tests: 113 → 116 (+3).

Codegen Lam machinery handled the wrapped form on the first try.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

examples/local_rec_as_value.ail.json

@@ -0,0 +1 @@
+{"defs":[{"body":{"args":[{"lit":{"kind":"int","value":5},"t":"lit"}],"fn":{"name":"f","t":"var"},"t":"app"},"doc":"Higher-order: applies its fn argument to 5.","kind":"fn","name":"apply5","params":["f"],"type":{"effects":[],"k":"fn","params":[{"effects":[],"k":"fn","params":[{"k":"con","name":"Int"}],"ret":{"k":"con","name":"Int"}}],"ret":{"k":"con","name":"Int"}}},{"body":{"body":{"cond":{"args":[{"name":"n","t":"var"},{"lit":{"kind":"int","value":1},"t":"lit"}],"fn":{"name":"<=","t":"var"},"t":"app"},"else":{"args":[{"name":"n","t":"var"},{"args":[{"args":[{"name":"n","t":"var"},{"lit":{"kind":"int","value":1},"t":"lit"}],"fn":{"name":"-","t":"var"},"t":"app"}],"fn":{"name":"factorial","t":"var"},"t":"app"}],"fn":{"name":"*","t":"var"},"t":"app"},"t":"if","then":{"lit":{"kind":"int","value":1},"t":"lit"}},"in":{"args":[{"args":[{"name":"factorial","t":"var"}],"fn":{"name":"apply5","t":"var"},"t":"app"}],"op":"io/print_int","t":"do"},"name":"factorial","params":["n"],"t":"letrec","type":{"effects":[],"k":"fn","params":[{"k":"con","name":"Int"}],"ret":{"k":"con","name":"Int"}}},"doc":"Iter 16b.5: pass a let-rec'd factorial as a value to apply5. Expected stdout: 120.","kind":"fn","name":"main","params":[],"type":{"effects":["IO"],"k":"fn","params":[],"ret":{"k":"con","name":"Unit"}}}],"imports":[],"name":"local_rec_as_value","schema":"ailang/v0"}

examples/local_rec_as_value.ailx

@@ -0,0 +1,33 @@
+; Iter 16b.5 — LetRec name as value (in_term, no capture).
+; A recursive `factorial` is bound by `(let-rec ...)` inside `main`,
+; then in the in-clause it is passed as a VALUE to a higher-order
+; combinator `apply5` (which expects `Fn(Int) -> Int`). Without
+; 16b.5, the desugar pass would panic with the "name-as-value not
+; supported" message. With 16b.5 it wraps the in-term in
+; `(let factorial (lam ...) ...)` whose lam eta-expands the lifted
+; top-level fn — so `factorial` reaches `apply5` as a closure-pair
+; value just like any other fn-value (Iter 7/8b ABI).
+;
+; Expected stdout: 120 (= apply5 factorial = factorial 5).
+
+(module local_rec_as_value
+
+  (fn apply5
+    (doc "Higher-order: applies its fn argument to 5.")
+    (type (fn-type (params (fn-type (params (con Int)) (ret (con Int)))) (ret (con Int))))
+    (params f)
+    (body (app f 5)))
+
+  (fn main
+    (doc "Iter 16b.5: pass a let-rec'd factorial as a value to apply5. Expected stdout: 120.")
+    (type (fn-type (params) (ret (con Unit)) (effects IO)))
+    (params)
+    (body
+      (let-rec factorial
+        (params n)
+        (type (fn-type (params (con Int)) (ret (con Int))))
+        (body
+          (if (app <= n 1)
+            1
+            (app * n (app factorial (app - n 1)))))
+        (in (do io/print_int (app apply5 factorial)))))))

examples/local_rec_as_value_capture.ail.json

@@ -0,0 +1 @@
+{"defs":[{"body":{"args":[{"lit":{"kind":"int","value":5},"t":"lit"}],"fn":{"name":"f","t":"var"},"t":"app"},"doc":"Higher-order: applies its fn argument to 5.","kind":"fn","name":"apply5","params":["f"],"type":{"effects":[],"k":"fn","params":[{"effects":[],"k":"fn","params":[{"k":"con","name":"Int"}],"ret":{"k":"con","name":"Int"}}],"ret":{"k":"con","name":"Int"}}},{"body":{"body":{"cond":{"args":[{"name":"n","t":"var"},{"lit":{"kind":"int","value":1},"t":"lit"}],"fn":{"name":"<=","t":"var"},"t":"app"},"else":{"args":[{"name":"n","t":"var"},{"args":[{"args":[{"name":"n","t":"var"},{"lit":{"kind":"int","value":1},"t":"lit"}],"fn":{"name":"-","t":"var"},"t":"app"}],"fn":{"name":"factorial_plus","t":"var"},"t":"app"}],"fn":{"name":"*","t":"var"},"t":"app"},"t":"if","then":{"args":[{"lit":{"kind":"int","value":1},"t":"lit"},{"name":"base","t":"var"}],"fn":{"name":"+","t":"var"},"t":"app"}},"in":{"args":[{"name":"factorial_plus","t":"var"}],"fn":{"name":"apply5","t":"var"},"t":"app"},"name":"factorial_plus","params":["n"],"t":"letrec","type":{"effects":[],"k":"fn","params":[{"k":"con","name":"Int"}],"ret":{"k":"con","name":"Int"}}},"doc":"Build a recursive helper that captures `base` and pass it as a value to apply5.","kind":"fn","name":"run_with_base","params":["base"],"type":{"effects":[],"k":"fn","params":[{"k":"con","name":"Int"}],"ret":{"k":"con","name":"Int"}}},{"body":{"lhs":{"args":[{"args":[{"lit":{"kind":"int","value":10},"t":"lit"}],"fn":{"name":"run_with_base","t":"var"},"t":"app"}],"op":"io/print_int","t":"do"},"rhs":{"args":[{"args":[{"lit":{"kind":"int","value":100},"t":"lit"}],"fn":{"name":"run_with_base","t":"var"},"t":"app"}],"op":"io/print_int","t":"do"},"t":"seq"},"doc":"Iter 16b.5: pass a capturing let-rec helper as a value. Expected stdout: 1320, 12120.","kind":"fn","name":"main","params":[],"type":{"effects":["IO"],"k":"fn","params":[],"ret":{"k":"con","name":"Unit"}}}],"imports":[],"name":"local_rec_as_value_capture","schema":"ailang/v0"}

examples/local_rec_as_value_capture.ailx

@@ -0,0 +1,43 @@
+; Iter 16b.5 — LetRec name as value, with capture. A recursive
+; helper `factorial_plus` captures the outer fn-param `base` and is
+; passed as a VALUE to a higher-order combinator. The lifted fn has
+; signature `factorial_plus$lr_N(n: Int, base: Int) -> Int`. The
+; eta-Lam wrap binds `factorial_plus` in the in-clause to a
+; `(lam (n) (app factorial_plus$lr_N n base))` — the Lam's free var
+; `base` becomes a closure-env capture under the standard 8b ABI.
+; This exercises the dynamic-env path (lifted fn has extra params,
+; the eta-Lam captures them).
+;
+; Expected stdout (one per line):
+;   apply5(factorial_plus[base=10])  = 5*4*3*2*(1+10)  = 1320
+;   apply5(factorial_plus[base=100]) = 5*4*3*2*(1+100) = 12120
+
+(module local_rec_as_value_capture
+
+  (fn apply5
+    (doc "Higher-order: applies its fn argument to 5.")
+    (type (fn-type (params (fn-type (params (con Int)) (ret (con Int)))) (ret (con Int))))
+    (params f)
+    (body (app f 5)))
+
+  (fn run_with_base
+    (doc "Build a recursive helper that captures `base` and pass it as a value to apply5.")
+    (type (fn-type (params (con Int)) (ret (con Int))))
+    (params base)
+    (body
+      (let-rec factorial_plus
+        (params n)
+        (type (fn-type (params (con Int)) (ret (con Int))))
+        (body
+          (if (app <= n 1)
+            (app + 1 base)
+            (app * n (app factorial_plus (app - n 1)))))
+        (in (app apply5 factorial_plus)))))
+
+  (fn main
+    (doc "Iter 16b.5: pass a capturing let-rec helper as a value. Expected stdout: 1320, 12120.")
+    (type (fn-type (params) (ret (con Unit)) (effects IO)))
+    (params)
+    (body
+      (seq (do io/print_int (app run_with_base 10))
+           (do io/print_int (app run_with_base 100))))))