lock(reify): meta.sx surface + bodyless #builtin decls + loud bails

REIFY Phase 0.0. Add the comptime type-metaprogramming surface as the
on-demand module modules/std/meta.sx (NOT the prelude — declaring its
data types in always-loaded core.sx interns them into every module's
type table and shifts every .ir snapshot):

  - EnumVariant / EnumInfo / TypeInfo data types. TypeInfo's variant uses
    the backtick raw escape `enum so it reads as the keyword.
  - reify / type_info / field_type as bodyless #builtin decls.

Each builtin bails LOUDLY when reached unimplemented (no silent default):
  - reify(...) in a :: type-alias position -> decl.zig .call branch
    (also the Phase 0.2 construction hook); poisons the alias .unresolved.
  - reify / field_type in any other type position ->
    generic.zig resolveTypeCallWithBindings.
  - type_info(...) in expression position -> call.zig tryLowerReflectionCall.

Unit test src/parser.test.zig (registered in root.zig) locks that the
decls parse. zig build test green (447 unit, 669 examples).

src/ir/lower/generic.zig

@@ -1219,6 +1219,22 @@ pub fn resolveTypeCallWithBindings(self: *Lowering, cl: *const ast.Call) TypeId
         .field_access => |fa| fa.field,
         else => return .unresolved,
     };
+    // Comptime type-construction builtins (REIFY). `reify`/`field_type`
+    // appear in type position (`E :: reify(...)`, `field_type(T, i)` as a
+    // type arg). Until the interpreter-side construction lands (Phase 0.2 /
+    // Phase 2), bail LOUDLY rather than fall through to the misleading
+    // "unknown type 'reify'" diagnostic below — a silent default here would
+    // poison every downstream use of the type.
+    if (std.mem.eql(u8, callee_name, "reify")) {
+        if (self.diagnostics) |d|
+            d.addFmt(.err, cl.callee.span, "reify is not yet implemented (REIFY Phase 0.2)", .{});
+        return .unresolved;
+    }
+    if (std.mem.eql(u8, callee_name, "field_type")) {
+        if (self.diagnostics) |d|
+            d.addFmt(.err, cl.callee.span, "field_type is not yet implemented (REIFY Phase 2)", .{});
+        return .unresolved;
+    }
     // Built-in: Vector(N, T)
     if (std.mem.eql(u8, callee_name, "Vector") and cl.args.len == 2) {
         const length = self.resolveVectorLane(cl.args[0]) orelse return .unresolved;