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/call.zig

@@ -1676,6 +1676,16 @@ 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, "type_info")) {
+        // Comptime reflection-into-data (REIFY). Until the interpreter-side
+        // reflection lands (Phase 2), bail loudly rather than fall through to
+        // the no-body `#builtin` const_decl path (which would mis-lower as a
+        // zero-arg call). A silent fall-through would hand the caller a
+        // garbage TypeInfo value.
+        if (self.diagnostics) |d|
+            d.addFmt(.err, c.callee.span, "type_info is not yet implemented (REIFY Phase 2)", .{});
+        return Ref.none;
+    }
     if (std.mem.eql(u8, name, "size_of")) {
         // size_of(T) → const_int(sizeof(T))
         const ty = self.resolveTypeArg(c.args[0]);