P5.7 Step D: re-express metatype declare() as sx over declare_type

declare(name) is now an ordinary sx fn in modules/std/meta.sx that calls the
abi(.compiler) declare_type primitive — both mint/find the same forward nominal
slot. Removed the bespoke .declare arm from callBuiltinVm and the BuiltinId.declare
member; dropped the declare interception in tryLowerReflectionCall (the call now
routes to the sx fn). preregisterForwardTypes still scans for the literal
declare("Name") spelling so *Name self-references forward-register before the
body lowers (0618). define/type_info/field_type remain builtins.

library/modules/std/meta.sx

@@ -6,8 +6,10 @@
 // types would otherwise intern into every module's type table and shift every
 // `.ir` snapshot. Import it explicitly:  #import "modules/std/meta.sx";
 //
-// All four are comptime-only builtins — reaching one at runtime is a hard error
-// (the type must be minted / reflected at compile time).
+// `declare` is ordinary sx (over the `abi(.compiler)` primitive `declare_type`);
+// `define` / `type_info` / `field_type` are comptime-only compiler builtins —
+// reaching one at runtime is a hard error (the type must be minted / reflected
+// at compile time).
 
 // One variant of a constructed enum: a name plus an optional payload type.
 // `payload = void` means a tagless variant (e.g. `closed`).
@@ -52,24 +54,57 @@ TypeInfo :: enum {
     `tuple: TupleInfo;
 }
 
-// The compiler's ONLY type-construction primitives (comptime-only #builtins):
+// ── The low-level compiler-API type-construction primitive ───────────────────
+//
+// `declare_type` is an `abi(.compiler)` function — the compiler's primitive for
+// minting a forward nominal slot, serviced by `comptime_vm.callCompilerFn`. It
+// runs at LOWERING time (when a `-> Type` builder's result is first referenced),
+// where the compiler still resolves references to the new type. The DSL's
+// `declare` below is ordinary sx written over it. (Declared here, not imported
+// from `modules/compiler.sx`, so `meta.sx` stays self-contained and doesn't
+// intern `compiler.sx`'s `List(string)` types into every importer's table.)
+declare_type :: (name: string) -> Type abi(.compiler);
+
+// ── The metatype DSL: `declare` (sx), `define`/`type_info`/`field_type` (builtins)
+//
 //   declare(name)        — mint a NEW empty (undefined) nominal type NAMED
 //                          `name`, returned as a `Type` handle. The compiler
-//                          registers the forward type at compile time, so the
+//                          registers the forward type at compile time (it scans
+//                          for the literal `declare("Name")` spelling), so the
 //                          body of `define` can reference it BY NAME — that's how
 //                          self-reference works (`payload = *List` resolves to the
 //                          forward `List`). Using the type before its `define` is
-//                          a loud error; a pointer to it is fine.
+//                          a loud error; a pointer to it is fine. A trivial alias
+//                          for `declare_type` (both mint the same forward slot).
 //   define(handle, info) — fill a declared handle's body from a `TypeInfo`, and
 //                          RETURN the handle so the one-shot form chains:
 //                              List :: define(declare("List"), .enum(.{ variants = .[
 //                                  EnumVariant.{ name = "cons", payload = *List },
 //                                  EnumVariant.{ name = "nil",  payload = void } ] }));
-declare    :: (name: string) -> Type #builtin;
+//                          Still a compiler builtin: decoding the `TypeInfo`
+//                          tagged-union VALUE needs comptime-VM tagged-union
+//                          matching (`enum_tag` on a tagged union), which the VM
+//                          doesn't model yet — so `define` can't be plain sx until
+//                          that lands (it would `match` the union).
+//   type_info($T)        — reflect a type INTO a `TypeInfo` value (the inverse of
+//                          `define`). Still a compiler builtin: building the
+//                          tagged-union value byte-compatibly is a compiler job.
+//   field_type($T, idx)  — the i-th field / variant-payload / element type. A
+//                          compiler builtin that folds at LOWER time, so it
+//                          composes inside `type_eq` / `type_name` / any type-arg
+//                          slot — a property `type_field_type` (a runtime value)
+//                          can't provide.
 define     :: (handle: Type, info: TypeInfo) -> Type #builtin;
 type_info  :: ($T: Type) -> TypeInfo #builtin;
 field_type :: ($T: Type, idx: i64) -> Type #builtin;
 
+// `declare(name)` is plain sx over the `declare_type` primitive: both mint (or
+// find) the same forward nominal slot — `declare` adds nothing but a name the
+// compiler scans for to forward-register self-references (`*Name`).
+declare :: (name: string) -> Type {
+    return declare_type(name);
+}
+
 // --- Type constructors built in sx library code (no compiler machinery) ---
 //
 // The channel result types, expressed as type-fns over declare/define. They