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).

src/ir/lower/decl.zig

@@ -2298,6 +2298,14 @@ pub fn declareFunction(self: *Lowering, fd: *const ast.FnDecl, name: []const u8)
     func.is_variadic = is_variadic;
     func.has_implicit_ctx = wants_ctx;
     if (weldedCompilerFn(self, fd, name)) func.compiler_welded = true;
+    // A non-generic `-> Type` builder is a comptime type constructor — only ever
+    // evaluated at lowering time (`runComptimeTypeFunc`) to mint a type, never
+    // called at runtime. Flag it `is_comptime` so its emitted body is dead: the
+    // comptime-only `compiler`-library gate then permits welded calls inside it
+    // (`register_type`/`declare_type`/`pointer_to`), exactly as in a #run/`::`
+    // wrapper. Without this, a builder that calls a welded fn would be rejected
+    // as "comptime-only fn called at runtime" even though it never runs at runtime.
+    if (fnReturnsTypeValue(fd)) func.is_comptime = true;
     self.fn_decl_fids.put(fd, fid) catch {};
 }