Iter 8b: lambdas with capture (Term::Lam + closure conversion)

Adds anonymous functions to AILang. A lambda value is constructed by
malloc'ing an env struct that holds its captured locals, plus a
closure pair `{ thunk_ptr, env_ptr }` (Iter 8a's ABI). The lambda's
body lifts to a top-level thunk `@ail_<m>_<def>_lam<id>(ptr %env,
params...)` that unpacks captures back into named locals before
running.

AST: new Term::Lam { params, paramTypes, retType, effects, body }.
Serde tag is "lam"; existing modules (no Lam) serialize identically,
so all current hashes stay stable.

Pretty-printer: renders `(\\ (x: T ...) -> R . body)`.

Typecheck (ailang-check): a lambda's type is the declared Type::Fn.
Body's effect set must be a subset of declared effects (no row
polymorphism). Constructing a lambda is pure — only calling it picks
up the declared effects, via the existing App branch.

Codegen (ailang-codegen):
- collect_captures: free-var walk; excludes builtins, current-module
  top-level fns, and qualified names.
- lower_lambda: per-fn lam counter, save/restore emitter state, emit
  thunk into a deferred queue (flushed after the parent fn), pack env
  + closure pair on heap, register the resulting closure-pair SSA in
  the sidetable so subsequent indirect calls find it.
- Capture sigs propagate: a fn-typed capture keeps its FnSig in the
  thunk's sidetable so `f(args)` inside the body still indirect-calls.
- Env layout: 8 bytes per capture (typed load/store reads only the
  needed bytes; padding wasted but uniform).

Tests: 49 green (was 48). New examples/closure.ail.json + e2e
`closure_captures_let_n` exercises `let n = 3 in apply(\\x. x + n, 39)`
end-to-end and asserts the binary prints 42.

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

examples/closure.ail.json

@@ -0,0 +1,77 @@
+{
+  "schema": "ailang/v0",
+  "name": "closure",
+  "imports": [],
+  "defs": [
+    {
+      "kind": "fn",
+      "name": "apply",
+      "type": {
+        "k": "fn",
+        "params": [
+          {
+            "k": "fn",
+            "params": [{ "k": "con", "name": "Int" }],
+            "ret": { "k": "con", "name": "Int" },
+            "effects": []
+          },
+          { "k": "con", "name": "Int" }
+        ],
+        "ret": { "k": "con", "name": "Int" },
+        "effects": []
+      },
+      "params": ["f", "x"],
+      "doc": "apply a fn-of-Int to an Int",
+      "body": {
+        "t": "app",
+        "fn": { "t": "var", "name": "f" },
+        "args": [{ "t": "var", "name": "x" }]
+      }
+    },
+    {
+      "kind": "fn",
+      "name": "main",
+      "type": {
+        "k": "fn",
+        "params": [],
+        "ret": { "k": "con", "name": "Unit" },
+        "effects": ["IO"]
+      },
+      "params": [],
+      "doc": "captures `n` from the enclosing let, returns 42",
+      "body": {
+        "t": "let",
+        "name": "n",
+        "value": { "t": "lit", "lit": { "kind": "int", "value": 3 } },
+        "body": {
+          "t": "do",
+          "op": "io/print_int",
+          "args": [
+            {
+              "t": "app",
+              "fn": { "t": "var", "name": "apply" },
+              "args": [
+                {
+                  "t": "lam",
+                  "params": ["x"],
+                  "paramTypes": [{ "k": "con", "name": "Int" }],
+                  "retType": { "k": "con", "name": "Int" },
+                  "effects": [],
+                  "body": {
+                    "t": "app",
+                    "fn": { "t": "var", "name": "+" },
+                    "args": [
+                      { "t": "var", "name": "x" },
+                      { "t": "var", "name": "n" }
+                    ]
+                  }
+                },
+                { "t": "lit", "lit": { "kind": "int", "value": 39 } }
+              ]
+            }
+          ]
+        }
+      }
+    }
+  ]
+}