fix(meta): def-meta :tag resolves uniformly (clj parity), retiring the bare-symbol workaround

Smell-audited: 1: no code behaviour change — D-316's uniform def-meta eval
(already in HEAD) is the finished form. A def-meta map analyzes as a real
expression, so a `:tag` symbol resolves like any value: `^String` yields the
Class (`(= String (:tag ...))` is true in cljw and clj), `^Foo` is a name
error. The pre-D-316 bare-symbol :tag was a pre-Class-resolution workaround,
retired now that class symbols resolve as values (v1.5.0). Only
phase14_var_metadata's meta_tag still asserted the workaround (`^Foo` => "Foo"),
which is why it failed four consecutive nightlies (2026-07-18..21). Flip it to
`(= String ...)` => true and add meta_tag_unresolvable (`^Foo` errors, the
correct clj-parity behaviour). special_forms.zig is comment-only, documenting
the uniform-eval intent so no :tag special case is re-added. No new AD:
structurally clj-equal, only the pre-existing AD-003 Class-print simple-name
divergence remains (applied to all Class values, not tag-specific).

Author: chaploud

src/eval/analyzer/special_forms.zig

@@ -533,7 +533,8 @@ pub fn analyzeDefmacro(
         try meta_items.append(arena, .{ .data = .{ .string = src_loc.file }, .location = form.location });
         const meta_map2: Form = .{ .data = .{ .map = try arena.dupe(Form, meta_items.items) }, .location = form.location };
         // Real-expression analysis, mirroring analyzeDef (D-316): quoted
-        // arglists stay data, computed values evaluate.
+        // arglists stay data, computed values evaluate, `:tag` symbols resolve
+        // uniformly (a Class value or a name error — clj parity).
         break :blk try analyzer_mod.analyze(arena, rt, env, scope, meta_map2, macro_table);
     };
 
@@ -688,6 +689,9 @@ pub fn analyzeDef(
         // `^{:k (+ 1 2)}` EVALUATES at def time — clj's def-meta semantics
         // exactly. The static formToValue lift above remains the pre-eval
         // approximation; the runtime value set by evalDef/op_var_meta wins.
+        // A `:tag` symbol is resolved uniformly like any other value — clj
+        // parity: `^String` yields the Class value, `^Foo` (unresolvable)
+        // is a name error, matching clj exactly (no bare-symbol special case).
         break :blk try analyzer_mod.analyze(arena, rt, env, scope, meta_map, macro_table);
     };
     // `^:dynamic` / `^:private` on the def target set the Var flags (evalDef /

test/e2e/phase14_var_metadata.sh

@@ -36,14 +36,28 @@ assert_last() {
     [[ "$got" == "$want" ]] || fail "$name: got '$got', want '$want'"
     echo "PASS $name -> $want"
 }
+# An expression that must be REJECTED (non-zero exit) — e.g. an unresolvable
+# type-hint tag, which is a name error in cljw exactly as in clj.
+assert_error() {
+    local name="$1"; local expr="$2"
+    if "$BIN" -e "$expr" >/dev/null 2>&1; then
+        fail "$name: expected an error, but it succeeded"
+    fi
+    echo "PASS $name -> (errored as expected)"
+}
 
 # --- ^{map} on a def target → Var meta, read via (meta #'x) ---
 assert_last 'meta_doc'     '(def ^{:doc "hi"} x 5) (:doc (meta #'"'"'x))'  '"hi"'
 assert_last 'meta_map_a'   '(def ^{:a 1 :b 2} z 5) (:a (meta #'"'"'z))'    '1'
 # --- ^:kw shorthand → {:kw true} ---
 assert_last 'meta_private' '(def ^:private y 5) (:private (meta #'"'"'y))' 'true'
-# --- ^Sym shorthand → {:tag Sym} (cljw keeps the bare symbol tag) ---
-assert_last 'meta_tag'     '(def ^Foo s 1) (str (:tag (meta #'"'"'s)))'    '"Foo"'
+# --- ^Sym type-hint shorthand → {:tag <Class>}: a def-meta map analyzes as a
+# real expression (D-316), so a resolvable class symbol resolves to the Class
+# VALUE — clj parity, `(= String (:tag …))` is true in both. An unresolvable
+# tag is a name error, same as clj. (The old bare-symbol tag was a
+# pre-Class-resolution workaround, retired once class symbols became values.) ---
+assert_last 'meta_tag'         '(def ^String s 1) (= String (:tag (meta #'"'"'s)))'  'true'
+assert_error 'meta_tag_unresolvable' '(def ^Foo s 1)'
 # --- stacked metas merge, outer wins on dup keys ---
 assert_last 'meta_stack'   '(def ^:a ^:b w 5) [(:a (meta #'"'"'w)) (:b (meta #'"'"'w))]' '[true true]'