green(reify): declare/define floor — reify is sx; E :: reify(...) comptime-evaluated

First slice of the re-architecture. The compiler gains two comptime
type-construction builtins — declare() (mint an empty/undefined nominal
slot) and define(handle, info) (decode a TypeInfo VALUE + complete the
slot) — executed by the interpreter against a new `mint` TypeTable handle
(setMintTable). reify becomes PLAIN sx in meta.sx:
  reify :: (info) -> Type { h := declare(); define(h, info); return h; }

`E :: f(...)` where f is a non-generic Type-returning fn (reify, and later
make_enum) is now comptime-evaluated via evalComptimeTypeNamed: wrap the
call in a throwaway comptime fn, run it through the interp with the mint
table enabled so declare/define mint the type, read back the type_tag, and
rename the anonymous slot to the binding name. The compiler has ZERO reify
knowledge at the decl site — the old `E :: reify` hook is deleted.

examples/0614 (inline reify) now runs on this floor. Full suite green (673).

INTERMEDIATE: reifyType + findReturnReifyCall still serve the type-fn path
(0615/0617) and will be deleted in the next slice (type-fn body
comptime-eval), after which the compiler has no reify code at all.

src/ir/lower/call.zig

@@ -1676,6 +1676,29 @@ pub fn tryLowerReflectionCall(self: *Lowering, name: []const u8, c: *const ast.C
     // classification covers all 7; it runs before dispatch.
     if (self.reflectionTypeArgGuard(name, c)) |sentinel| return sentinel;
 
+    if (std.mem.eql(u8, name, "declare")) {
+        // Comptime type-construction primitive (REIFY floor): mint an empty
+        // nominal slot. Comptime-only — emitted as a builtin_call the interp
+        // executes against its `mint` table; never reaches codegen (reify and
+        // friends, which call it, are only ever comptime-evaluated).
+        if (c.args.len != 0) {
+            if (self.diagnostics) |d| d.addFmt(.err, c.callee.span, "declare() takes no arguments", .{});
+            return Ref.none;
+        }
+        return self.builder.callBuiltin(.declare, &.{}, .any);
+    }
+    if (std.mem.eql(u8, name, "define")) {
+        // Comptime type-construction primitive (REIFY floor): complete a
+        // declare()'d slot from a TypeInfo value. `define(handle, info)`.
+        if (c.args.len != 2) {
+            if (self.diagnostics) |d| d.addFmt(.err, c.callee.span, "define(handle, info) takes exactly two arguments", .{});
+            return Ref.none;
+        }
+        const handle_ref = self.lowerExpr(c.args[0]);
+        const info_ref = self.lowerExpr(c.args[1]);
+        const args_owned = self.alloc.dupe(Ref, &.{ handle_ref, info_ref }) catch return Ref.none;
+        return self.builder.callBuiltin(.define, args_owned, .void);
+    }
     if (std.mem.eql(u8, name, "type_info")) {
         // Comptime reflection-into-data (REIFY). Until the interpreter-side
         // reflection lands (Phase 2), bail loudly rather than fall through to