feat(types): tagged-union enums — variant payloads + binding match + exhaustiveness (#56)

Extend `enum` from named int constants to a tagged union: a variant may
carry a payload (`enum Tile { Empty, Wall, Door(int), Portal(int, int) }`).
Such enums box to a heap record (an i32 tag at offset 0, then one 8-byte
slot per payload position); an all-bare enum keeps its zero-cost compile-
time-ordinal representation, byte-for-byte unchanged (every golden render
and the bootstrap fixpoint still hold).

- Parser: variant payload declarations, stored as N_PARAM kids on the
  variant node.
- Construction: by name — `Door(3)`, `Portal(x, y)`, bare `Empty` — resolved
  ahead of the function-call fallback and boxed with the payloads coerced to
  their declared types.
- match: destructures a tagged scrutinee, switching on the tag and binding
  each arm's payload names in a scoped local frame.
- Checking pass: a tagged `match` must be exhaustive (cover every variant or
  end in `_`), and constructor/pattern arities and binding forms are checked
  — all reported where the scrutinee's type is known.

Adds selfhost/tests/enums.ludic to the regression suite and documents the
feature in LANGUAGE.md and the enum/match pages.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

selfhost/frontend/parse_game.ludic

@@ -210,10 +210,25 @@ function parse_scene() -> void {
 # enum Name { A, B, C } — named int constants; a variant's value is its index.
 # Accessed as `Name.A` (a compile-time int), so it names magic-int value spaces
 # (state ids, menu selections, mode registers) without a runtime cost.
+#
+# A variant may also carry a payload — `enum Tile { Empty, Wall, Door(int),
+# Portal(int, int) }` (issue #56). A payload turns the whole enum into a tagged
+# union: variants are constructed by name (`Door(3)`, bare `Empty`) and boxed
+# (a tag + payload slots), and `match` destructures them (`Door(n) => …`). An
+# all-payload-less enum keeps the zero-cost compile-time-ordinal representation.
+# Each variant node is an E_ID (s=variant name); its payload types are stored as
+# N_PARAM kids, one per slot, carrying only `.ty`.
 function parse_enum() -> Node {
   pi = pi + 1; let n = node(N_ENUM); n.s = eat_id(); skipnl(); eat_op("{")
   while true { skipnl(); if is_op("}") { break }
-    let v = node(E_ID); v.s = eat_id(); push(n.kids, v)
+    let v = node(E_ID); v.s = eat_id()
+    if is_op("(") {                              # variant payload: Door(int), Portal(int, int)
+      pi = pi + 1; skipnl()
+      while not is_op(")") {
+        let p = node(N_PARAM); p.ty = ptype(); push(v.kids, p)
+        if is_op(",") { pi = pi + 1 };  skipnl() }
+      eat_op(")") }
+    push(n.kids, v)
     if is_op(",") { pi = pi + 1 };  skipnl() }
   eat_op("}"); return n
 }