docs+rename: erase the reify name everywhere — stream is METATYPE

The compiler concept is declare/define (comptime type construction); the
old "reify" framing is gone from the entire repo.

- Rename: PLAN-REIFY → PLAN-METATYPE, CHECKPOINT-REIFY → CHECKPOINT-METATYPE,
  PLAN-POST-REIFY → PLAN-POST-METATYPE (both rewritten around declare/define);
  examples 0614/0615/0617 → comptime-metatype-* (+ their expected/ triplets),
  headers rewritten.
- Scrub reify from design/execution-evolution-roadmap.md (§7 step 3 contracts,
  §8.1, §9 decisions, §10 gates) → declare/define / comptime type construction.
- core.sx prelude pointer + parser.test.zig surface lock updated to the
  declare/define builtins (define(handle, info) -> Type; EnumInfo.name).

No behavior change; renamed examples match their renamed snapshots. Full
suite green (673), all unit tests pass. Zero `reify` tokens remain in
src/docs/sx/examples.

design/execution-evolution-roadmap.md

@@ -27,8 +27,8 @@ features into codegen. Concretely:
 
 The honest trade is **small *surface*, but each primitive is *deep*** — not "small
 compiler." The net-new **compiler** obligations this plan adds (all verified absent
-today): **atomics lowering** (N1), **generic enums** `enum($T)`, **`type_info` +
-`reify` + `field_type`** (comptime type construction), **`callconv(.naked)`**,
+today): **atomics lowering** (N1), **generic enums** `enum($T)`, **`declare` +
+`define` + `type_info` + `field_type`** (comptime type metaprogramming), **`callconv(.naked)`**,
 **repointable-`context` codegen** (+ per-fiber stack-limit), the **S1 persistent JIT
 spine**, **C1 thunk synthesis**, **comptime-asm lifting** (C3), and (later) the **S2
 ORC C++ shim**. Async itself is genuinely a library; the *enabling primitives* are a
@@ -363,36 +363,38 @@ grounding) are explicit steps, not buried.
    `atomicrmw`/`cmpxchg`/`fence` emission + orderings. Surface = `Atomic($T)` wrapper.
    Gates channels/N3 + parallel schedulers.
 2. ~~**Generic enums** `enum($T)`~~ **DROPPED.** `RecvResult($T)`/`TryResult($T)` are
-   **type-fns over `reify`** (step 3), not a new `enum($T)` language feature — and
-   type-fns (user `($T)->Type` in type position) **already work** (e.g.
+   **type-fns over `declare`/`define`** (step 3), not a new `enum($T)` language
+   feature — and type-fns (user `($T)->Type` in type position) **already work** (e.g.
    [`Make`](../examples/0208-generics-value-param-type-function.sx),
    [`Complex`](../examples/0201-generics-generic-struct.sx)). A declarative `enum($T)`
-   surface, if ever wanted, is later *sugar* desugaring to a type-fn-over-`reify`.
-3. **`type_info` + `reify` + `field_type`** — comptime metaprogramming floor. Gates
-   `race` synthesis **and** channel `RecvResult`/`TryResult` (all type-fns over
-   `reify`; **generic-enum syntax dropped**). **Validated against the codebase (3
-   reviewers): a small extension reusing existing machinery throughout — not net-new
-   architecture.** Five contracts:
+   surface, if ever wanted, is later *sugar* desugaring to a type-fn over the primitives.
+3. **`declare`/`define` (construction) + `type_info`/`field_type` (reflection)** —
+   comptime metaprogramming floor. Gates `race` synthesis **and** channel
+   `RecvResult`/`TryResult` (all sx type-fns over `declare`/`define`; **generic-enum
+   syntax dropped**). **Validated against the codebase (3 reviewers): a small
+   extension reusing existing machinery throughout — not net-new architecture.**
+   Contracts:
    1. **Nominal identity via type-fn memoization** — type-fns dedup by mangled
-      `(fn,args)` name (generic.zig:1620-1629) + reify `findByName`, so `RecvResult(i64)`
-      is one `TypeId` and the body runs once. (NOT structural dedup — enums are
-      nominal via `nominal_id`, types.zig:1110.)
+      `(fn,args)` name (generic.zig) + `findByName`, so `RecvResult(i64)` is one
+      `TypeId` and the body runs once. (NOT structural dedup — enums are nominal via
+      `nominal_id`, types.zig.)
    2. **Functional through codegen** — layout / construct / match+exhaustiveness /
       `toLLVMType` / `type_name`+format are **all type-table-driven, zero AST
-      coupling**, so a backing-decl-less reify'd enum flows through unmodified.
+      coupling**, so a backing-decl-less minted enum flows through unmodified.
    3. **Validate loudly** at the single `intern`/`internNominal` choke point
-      (types.zig:411-439): reject dup variants / bad backing / unresolved payloads.
+      (types.zig): reject dup variants / bad backing / unresolved payloads.
    4. **Comptime-only, JIT-free** — a type-table op in the interp; no S1 dependency
-      (keeps reify, hence channels + `race`, off the JIT critical path).
-   5. **Reference-based self-reference (v1)** — `*Self`/`[]Self` payloads via the
-      reserve-placeholder→complete path recursive *source* types already use
-      (nominal.zig:86/108/120, types.zig:442); **by-value recursion rejected** (loud,
-      infinite size). reify gains a `reify_rec((self) => …)` builder form.
+      (keeps construction, hence channels + `race`, off the JIT critical path).
+   5. **Reference-based self-reference** — `*Self`/`[]Self` payloads via the
+      explicit `declare()` → `define(handle, …)` split (the handle predates its
+      body, so it can be referenced inside it); **by-value recursion rejected**
+      (loud, infinite size). Reuses the reserve-placeholder→complete path recursive
+      *source* types already use (nominal.zig, types.zig).
    - **Type-minting precedents (7):** monomorphization, protocol vtables, tuples,
      vector/array, ptr/slice ctors, FFI stubs, **type-fn instantiation** — all
      construct `TypeInfo` programmatically + `intern()`. **Residual = plumbing, not
-     capability:** name reify-results by the instantiation's mangled name (done for
-     inline-struct bodies — extend to reify-results) + reify input validation.
+     capability:** name minted results by the instantiation's mangled name + input
+     validation.
 4. **`callconv(.naked)`** — extend `CallConv {default, c}` (types.zig:169) + skip
    prologue/epilogue lowering. Gates A2.
 5. **Repointable-`context` codegen** — lower `context` as a swappable indirection
@@ -447,11 +449,11 @@ persistent, only leaf logic reloads).
    *scheduling*, not the *switch*); a one-register slip is invisible until it crashes
    on the right arch. Couples *library asm* to the *compiler ABI* — ABI drift breaks
    it silently later. → needs a dedicated **switch-stress test** (§10).
-2. **`reify` → anonymous-tagged-union → match-codegen** (gates `race` + channels).
+2. **`define` → tagged-union → match-codegen** (gates `race` + channels).
    **DE-RISKED by review** (§7 step 3): all enum stages are type-table-driven with
    zero AST coupling, identity is handled by existing type-fn mangled-name memoization,
    and forward-declaration for self-ref already exists. Residual is *plumbing*
-   (name reify-results by mangled name + input validation), not new architecture.
+   (name minted results by mangled name + input validation), not new architecture.
 3. **Deterministic-`Io` is the test keystone yet itself uncalibrated** — a buggy
    deterministic scheduler yields deterministic-*wrong* stdout that snapshots lock in.
    → calibrate against the blocking `Io` / property-test fixed order (§10).
@@ -477,9 +479,10 @@ precedes the FFI/JIT cluster (15–18) because async needs no JIT spine. **Cance
 the "keep calls clean" argument for the non-local-`raise` model is moot). Reuses
 `!`/`try`/`catch`/`onfail`; no new unwind primitive. **Net-new prereq surfaced by
 grounding:** `callconv(.naked)` (only `.default`/`.c` today). **Generic enums dropped**
-— `RecvResult($T)`/`TryResult($T)` are **type-fns over `reify`** (type-fns already work
-in type position, e.g. `Make`/`Complex`), so no `enum($T)` feature is needed; `reify`
-gains two contracts (deterministic identity + functional-enum output, §7 step 3).
+— `RecvResult($T)`/`TryResult($T)` are **type-fns over `declare`/`define`** (type-fns
+already work in type position, e.g. `Make`/`Complex`), so no `enum($T)` feature is
+needed; construction carries two contracts (deterministic identity + functional-enum
+output, §7 step 3).
 
 **Locked (see §4.6 for the grounded surface):**
 - **N1 atomics surface = generic wrapper `Atomic($T)`** + `Ordering` enum, `.init`,
@@ -493,10 +496,11 @@ gains two contracts (deterministic identity + functional-enum output, §7 step 3
   `RecvResult($T){ value; closed }` (not `(v, ok)`), `try_recv` → `{ value; empty;
   closed }`; optional `for ch (v) {…}` iteration sugar. **locks** = `lock()` + `defer
   unlock()` (no guard sugar). `race`/`async`/`await` stay library, not keywords.
-- **Comptime type metaprogramming = `type_info` + `reify` builtins only** (Zig
-  `@typeInfo`/`@Type` model). **Everything else is sx lib** — `make_enum`,
-  `field_type`, `RaceResult`. `reify` coverage starts at **enum/struct/tuple**, grows
-  later. `Future($T)` exposes `Value :: T` so `Future(X)→X` is plain member access
+- **Comptime type metaprogramming = `declare`/`define` (construct) + `type_info`
+  (reflect) builtins only** (Zig `@Type`/`@typeInfo` model). **Everything else is sx
+  lib** — `make_enum`, the channel result types, `field_type`, `RaceResult`.
+  Construction coverage starts at **enum**, grows to struct/tuple later. `Future($T)`
+  exposes `Value :: T` so `Future(X)→X` is plain member access
   (no `type_arg` builtin).
 - **C1 FFI engine = LLVM as single ABI authority** — per-signature JIT calling-thunks
   via S1 (LLVM emits the ABI-correct call, same as runtime codegen); trampoline
@@ -571,8 +575,8 @@ per-arch run tests on matching runners.
 ### 10.4 New corpus categories
 
 `17xx` atomics · `18xx` concurrency (fibers/channels/race/async, all under the
-deterministic `Io`). Comptime metaprogramming (`type_info`/`reify`) + comptime-asm
-extend `06xx`; C1 FFI extends `12xx`; the cross-arch comptime-asm **loud bail** and
+deterministic `Io`). Comptime metaprogramming (`declare`/`define`/`type_info`) +
+comptime-asm extend `06xx`; C1 FFI extends `12xx`; the cross-arch comptime-asm **loud bail** and
 the cancellation diagnostics are `11xx`.
 
 ### 10.5 Per-piece gates (design level)
@@ -580,7 +584,7 @@ the cancellation diagnostics are `11xx`.
 | Piece | Locks via |
 |---|---|
 | **N1 atomics** | unit `emit_llvm.test.zig` (LLVM `atomicrmw`/`cmpxchg`/`fence` + ordering emission); corpus `17xx` single-thread (deterministic); arch-gated `.ir` (x86_64 + aarch64) |
-| **type_info / reify** | unit (reflect round-trips; reify'd enum has correct layout/match codegen); corpus `06xx` comptime (deterministic) |
+| **declare / define / type_info** | unit (reflect round-trips; a minted enum has correct layout/match codegen); corpus `06xx` comptime (deterministic) |
 | **C1 FFI** | **behavior-lock** existing trampoline cases first; then xfail→green `12xx` comptime extern with floats / structs-by-value / aggregate (`{ptr,len}`) returns; unit for thunk-synth + args-buffer marshal |
 | **S1 spine** | infra — exercised transitively via C1/C3 examples; unit for LLJIT lifecycle + thunk cache |
 | **C3 comptime asm** | corpus `06xx` host-arch `#run` asm computes a value; `11xx` diagnostic asserts the cross-arch loud bail |