ffi M5.A.next.4.1: interp arms for reflection builtins on .type_tag

Second slice of the .type_tag activation. The reflection
intrinsics (`type_name`, `type_eq`, `has_impl`) now have
interp-time implementations that read `.type_tag` Values
directly. Today's lower-time fast path (folding to
`const_string`/`const_bool` when the type arg is statically
resolvable) stays — these interp arms are the fallback path
for when lowering emits a real `builtin_call` because the
arg is interp-time-only (e.g. `args[i]` inside a builder body
where the pack element is bound at interp execution).

Plumbing:
- New BuiltinId entries: `type_name`, `type_eq`, `has_impl`.
- Interp arms in `execBuiltinInner`:
  - `type_name(t)`: reads `.type_tag` via `asTypeId`, looks up
    via `module.types.typeName`, dupes the slice into the
    interp allocator, returns `.string`. Non-`.type_tag` arg
    → `bailDetail` ("argument is not a Type value").
  - `type_eq(a, b)`: both args must be `.type_tag`; compares
    TypeIds. Either side missing → `bailDetail`.
  - `has_impl(P, T)`: bails with a "not yet wired" message —
    interp-time has_impl needs a queryable snapshot of the
    host's `protocol_thunk_map` + `param_impl_map`, which is
    its own follow-up slice. Static-arg has_impl still works
    via the lower-time `tryConstBoolCondition` fast path.
- emit_llvm: explicit arms for the three new builtins that
  log + map to undef-i64 (Type values are comptime-only; if
  one of these reaches LLVM emit, lowering produced wrong
  IR — the LLVM verifier downstream surfaces the offending
  site).

Three new Zig unit tests in interp.test.zig:
- `type_name builtin on type_tag` — emits a `builtin_call`
  to `type_name` with a `const_type(s64)` operand, asserts
  the result is the string "s64".
- `type_eq builtin on type_tag values` — two equal Type
  operands compare equal.
- (Pre-existing) `const_type yields type_tag` + `type_tag
  comparison` from 4.0 still pass.

208/208 example tests + `zig build test` green. No source-
language path constructs `.type_tag` yet — the foundation is
ready for the `$args`-in-expression-position slice that
turns it on for users.

src/ir/interp.test.zig

@@ -713,3 +713,50 @@ test "comptime: type_tag comparison" {
     const r_false = try interp.call(FuncId.fromIndex(1), &.{});
     try std.testing.expectEqual(false, r_false.asBool().?);
 }
+
+// ── Test: type_name builtin reads .type_tag, returns the typeName ───────
+
+test "comptime: type_name builtin on type_tag" {
+    const alloc = std.testing.allocator;
+    var module = Module.init(alloc);
+    defer module.deinit();
+    var b = Builder.init(&module);
+
+    _ = b.beginFunction(str(&module, "test_type_name"), &.{}, .string);
+    const entry = b.appendBlock(str(&module, "entry"), &.{});
+    b.switchToBlock(entry);
+    const t = b.constType(.s64);
+    var args = [_]inst_mod.Ref{t};
+    const r = b.callBuiltin(.type_name, &args, .string);
+    b.ret(r, .string);
+    b.finalize();
+
+    var interp = Interpreter.init(&module, alloc);
+    defer interp.deinit();
+    const result = try interp.call(FuncId.fromIndex(0), &.{});
+    try std.testing.expectEqualStrings("s64", result.asString(&interp).?);
+}
+
+// ── Test: type_eq builtin on two .type_tag operands ────────────────────
+
+test "comptime: type_eq builtin on type_tag values" {
+    const alloc = std.testing.allocator;
+    var module = Module.init(alloc);
+    defer module.deinit();
+    var b = Builder.init(&module);
+
+    _ = b.beginFunction(str(&module, "test_type_eq_builtin"), &.{}, .bool);
+    const entry = b.appendBlock(str(&module, "entry"), &.{});
+    b.switchToBlock(entry);
+    const a = b.constType(.string);
+    const c = b.constType(.string);
+    var args = [_]inst_mod.Ref{ a, c };
+    const r = b.callBuiltin(.type_eq, &args, .bool);
+    b.ret(r, .bool);
+    b.finalize();
+
+    var interp = Interpreter.init(&module, alloc);
+    defer interp.deinit();
+    const result = try interp.call(FuncId.fromIndex(0), &.{});
+    try std.testing.expectEqual(true, result.asBool().?);
+}