Iter 10: Term::Seq sequencing operator

Adds `Term::Seq { lhs, rhs }` (serde tag "seq") as a first-class
AST node for sequencing effectful expressions. Equivalent in
behaviour to `let _ = lhs in rhs`, but the dedicated node gives the
pretty-printer and diagnostics a cleaner shape and surfaces the
intent ("run for effect, then yield rhs") to future tooling.

Typecheck: lhs must be Unit; rhs's type is the result; effects
accumulate.
Codegen: lower lhs (drop SSA), lower rhs (return).
Capture / deps walkers: recurse into both sides.

Refactored examples/list_map.ail.json's print_list to use seq
instead of `let _ = ...`. Output unchanged (2/4/6).

Hash stability: existing examples without Term::Seq serialise
bit-identical; only list_map.ail.json's hashes changed (deliberate
refactor).

Tests: 51 green (was 50). New unit test
`ailang_check::tests::seq_lhs_must_be_unit` covers the type-error
path; existing list_map e2e covers the happy path.

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

crates/ailang-core/src/ast.rs

@@ -142,6 +142,14 @@ pub enum Term {
         effects: Vec<String>,
         body: Box<Term>,
     },
+    /// Sequencing (Iter 10). `lhs` is evaluated for its effects and its
+    /// result discarded; `rhs` is the value of the whole expression.
+    /// Equivalent to `let _ = lhs in rhs`, but with a dedicated node so
+    /// pretty-print and diagnostics read cleanly.
+    Seq {
+        lhs: Box<Term>,
+        rhs: Box<Term>,
+    },
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]

crates/ailang-core/src/pretty.rs

@@ -220,6 +220,14 @@ fn term_block(t: &Term, indent: usize) -> String {
             s.push(')');
             s
         }
+        Term::Seq { lhs, rhs } => {
+            let mut s = format!("{pad}(seq\n");
+            s.push_str(&term_block(lhs, indent + 2));
+            s.push('\n');
+            s.push_str(&term_block(rhs, indent + 2));
+            s.push(')');
+            s
+        }
     }
 }
 
@@ -298,6 +306,9 @@ fn term_inline(t: &Term) -> String {
         Term::Lam { params, .. } => {
             format!("(\\ {} ...)", params.join(" "))
         }
+        Term::Seq { lhs, rhs } => {
+            format!("(seq {} {})", term_inline(lhs), term_inline(rhs))
+        }
     }
 }