comptime VM: Phase 3 — register_type write side + payloadless-enum fixes

The mutating compiler-API, minting types LAZILY at lowering time (single pass,
the existing runComptimeTypeFunc path — so the write side is legacy-only; the
VM isn't wired at lowering time, and the read-side readers stay dual-path):

  declare_type(name) -> Type            forward nominal handle (≈ declare)
  pointer_to(t) -> Type                 build *T references
  register_type(handle, kind, members)  ONE kind-branching fill (≈ unified define)

register_type branches on kind IN THE COMPILER (subsuming define's per-kind
dispatch); codes match type_kind: 1 struct, 2 actual .@"enum", 3 tagged_union,
4 tuple. Members are {name: string, ty: Type}. A non-generic `-> Type` builder is
now flagged is_comptime (decl.zig) so its dead body permits the welded calls.

Graph support: forward declare_type handles + pointer_to express a mutually-
recursive A<->B graph (*A, *B, B-by-value) before bodies are filled. register_type
is idempotent — re-filling a nominal slot (a minting module reached via two import
edges) re-mints identically rather than erroring (nominalIdent reads identity from
any nominal kind).

Fixes (issue 0142):
- A fully payloadless comptime-minted enum was minted as an all-void tagged_union,
  whose IR size disagrees with its LLVM size -> verifySizes panic. Now mints a real
  .@"enum" (register_type kind 2 AND the metatype defineEnum).
- Bare `EnumType.variant` qualified construction of a payloadless variant wasn't
  supported (failed for hand-written enums too — the type name lowered to a Type
  value). Added in lowerFieldAccess via isPayloadlessVariant; payload-carrying
  variants keep their call form.

Examples: 0631 (graph + actual enum + reflection), 0632 (make_enum all-void),
0633/0634/0635 (namespaced / bare / multi-edge import of a minted type), 0187
(qualified variant construction). Unit tests added.

Parity 697/697 (gate OFF and -Dcomptime-flat).

current/CHECKPOINT-COMPILER-API.md

@@ -325,6 +325,26 @@ when reached (sentinels or accessor fns; see the design doc Risks).
   `List` growth; orthogonal, see `current/CHECKPOINT-METATYPE.md`.)
 
 ## Log
+- **Phase 3 P3.3 (VM plan) — WRITE side: declare_type + pointer_to + ONE kind-branching register_type (2026-06-18).**
+  The mutating compiler-API: `declare_type(name) -> Type` (forward handle), `pointer_to(t) -> Type`
+  (build `*T`), and `register_type(handle, kind, members: []Member) -> Type` which branches on
+  `kind` IN THE COMPILER (subsuming define's per-kind dispatch). Take/return real `Type` values
+  (matching meta.sx declare/define). **Timing (per user): mint LAZILY at lowering time, single
+  pass** (the existing `runComptimeTypeFunc`), so the write side is **legacy-only** (`compiler_lib`
+  handlers) — the VM isn't wired at lowering time, no VM mirror needed; readers stay dual-path.
+  A non-generic `-> Type` builder is now flagged `is_comptime` (decl.zig) so its dead body permits
+  the welded calls. **Graph:** forward handles + `pointer_to` express mutually-recursive A↔B (`*A`,
+  `*B`, B-by-value); `register_type` is **idempotent** (re-fill a nominal slot reached via two
+  import edges — `nominalIdent`). `kind` codes match `type_kind` (1 struct · 2 actual `.@"enum"` ·
+  3 tagged_union · 4 tuple). **Fixed two bugs (issue 0142):** (a) a fully payloadless minted enum
+  was an all-void tagged_union → verifySizes panic; now a real `.@"enum"` (register_type kind 2 AND
+  metatype `defineEnum`); (b) bare `EnumType.variant` payloadless qualified construction wasn't
+  supported (failed for hand-written enums too) — added in `lowerFieldAccess` (`isPayloadlessVariant`).
+  Examples 0631 (graph + actual enum + reflection), 0632 (make_enum all-void), 0633/0634/0635
+  (namespaced / bare / multi-edge import of a minted type), 0187 (qualified variant construction).
+  **Parity 697/697** (gate ON and OFF); unit tests added. **Next (P3.4):** re-express
+  declare/define/type_info as sx over the compiler-API + delete the bespoke interp arms (needs the
+  VM hardened for lowering-time IR, or the metatype migrated onto the legacy compiler-API calls).
 - **Phase 3 P3.2b (VM plan) — kind + enum-value readers: `type_kind` + `type_field_value`; READ side complete (2026-06-18).**
   The last two read-only readers the metatype's `type_info(T)` needs (added to
   `compiler_lib.bound_fns` AND `Vm.callCompilerFn`, each backed by a `TypeTable` query both