Iter 18c.1: Term::Clone schema (no inc emission yet)

Adds (clone X) as a new Term variant. Form-A:
  (let p (expensive_fn x)
    (do consume_a (clone p))    ; explicit RC inc — needs 18c.3
    (do consume_b p))

Schema floor for the LLM-aware RC design (Decision 10): explicit
clone is the author-visible alternative to implicit sharing. In
18c.1 the variant is purely additive — typechecker treats it as
identity (same type as inner), codegen lowers it to the inner
term's IR with no extra calls. Iter 18c.3 will replace the
codegen identity-arm with a single call:

  Term::Clone { value } =>
      let v = self.lower_term(value, ...)?;
      self.emit("call void @ailang_rc_inc(ptr {v})");
      Ok(v)

Match-arm count: ~10 sites across 6 files, all mechanical
structural recursion through `value`. The codegen `lower_term`
arm carries an explicit comment marking the 18c.3 emission seam.

Hash invariant: `(clone X)` uses a new serde tag "clone" that no
pre-18c.1 fixture contains. Every existing fixture's canonical
JSON is bit-identical (git diff examples/ empty).

New fixture examples/clone_demo.{ailx,ail.json}:
  (let x 42 (do io/print_int (clone x)))
Stdout 42 under both --alloc=gc and --alloc=rc.

Tail-position propagates through clone (verify_tail_positions
treats `(clone tail-call)` as itself a tail call), per the
identity-of-clone semantics in 18c.1.

Verified:
- cargo build --workspace clean
- cargo test --workspace green: 52 e2e (+1), 14 surface parse
  (+2 for clone tests), all other buckets unchanged
- ail render round-trip exact
- clone_demo --alloc=gc → 42; --alloc=rc → 42

crates/ailang-codegen/src/escape.rs

@@ -179,6 +179,11 @@ fn walk(t: &Term, out: &mut NonEscapeSet) {
             walk(body, out);
             walk(in_term, out);
         }
+        Term::Clone { value } => {
+            // Iter 18c.1: clone is identity at IR level — only walk
+            // sub-terms looking for Let-allocation candidates.
+            walk(value, out);
+        }
         Term::Lit { .. } | Term::Var { .. } => {}
     }
 }
@@ -338,6 +343,12 @@ fn escapes(t: &Term, tainted: &BTreeSet<String>, in_tail: bool) -> bool {
             // declare escape.
             true
         }
+        Term::Clone { value } => {
+            // Iter 18c.1: clone is identity. The wrapper's escape
+            // verdict is exactly that of its inner term, threaded
+            // through with the same `in_tail` context.
+            escapes(value, tainted, in_tail)
+        }
     }
 }
 
@@ -433,6 +444,10 @@ fn collect_free_vars(t: &Term, bound: &mut BTreeSet<String>, out: &mut BTreeSet<
             collect_free_vars(body, bound, out);
             collect_free_vars(in_term, bound, out);
         }
+        Term::Clone { value } => {
+            // Iter 18c.1: clone is identity for free-var collection.
+            collect_free_vars(value, bound, out);
+        }
     }
 }
 

crates/ailang-codegen/src/lib.rs

@@ -1154,6 +1154,11 @@ impl<'a> Emitter<'a> {
                 // here is a bug.
                 unreachable!("Term::LetRec eliminated by desugar")
             }
+            Term::Clone { value } => {
+                // Iter 18c.1: clone is identity. Iter 18c.3 will emit
+                // `call void @ailang_rc_inc` here under --alloc=rc.
+                self.lower_term(value)
+            }
         }
     }
 
@@ -2308,6 +2313,11 @@ impl<'a> Emitter<'a> {
                 // Iter 16b.1: eliminated by desugar before codegen.
                 unreachable!("Term::LetRec eliminated by desugar")
             }
+            Term::Clone { value } => {
+                // Iter 18c.1: clone is identity for capture analysis —
+                // free vars of `(clone X)` are exactly the free vars of `X`.
+                Self::collect_captures(value, bound, captures, captures_set, builtins, top_level);
+            }
         }
     }
 
@@ -2814,6 +2824,10 @@ impl<'a> Emitter<'a> {
                 // Iter 16b.1: eliminated by desugar before codegen.
                 unreachable!("Term::LetRec eliminated by desugar")
             }
+            Term::Clone { value } => {
+                // Iter 18c.1: clone is identity — same type as inner.
+                self.synth_with_extras(value, extras)
+            }
         }
     }
 }
@@ -3203,6 +3217,10 @@ fn apply_subst_to_term(t: &Term, subst: &BTreeMap<String, Type>) -> Term {
             // monomorphisation pass runs.
             unreachable!("Term::LetRec eliminated by desugar")
         }
+        Term::Clone { value } => Term::Clone {
+            // Iter 18c.1: structural recursion through the wrapper.
+            value: Box::new(apply_subst_to_term(value, subst)),
+        },
     }
 }