core: Stage 2 Task 2 tier 2b — compile reify (make-reified as a fn)

Completes the protocol machinery: make-reified joins protocol-dispatch/
register-method as a ctx-capturing clojure.core fn (install-stateful-fns!).
- make-reified-impl takes the EVALUATED {keyword fn} method map (a phm when
  compiled, struct/table when interpreted) and builds the reified object.
- reify macro passes the protocol NAME as a string; method map is an ordinary
  map literal evaluating to {keyword fn}.
- Removed make-reified's special-symbol? entry + handler arm, and dropped
  make-reified + reify from host_iface special-names + compiler
  uncompilable-heads.

reify now compiles and dispatches in both modes (single- and multi-method).
With tier 2a, the full protocol surface (defprotocol/extend-type/
extend-protocol/reify) compiles; defrecord still waits on deftype (tier 5).

Gate green: conformance 267x3, fallback-zero 31/5, bootstrap-fixpoint
stage1==2==3, self-host, staged-bootstrap, clojure-test-suite >=4034/67,
features 78/78, all unit + spec (protocols 7/7x3).

jolt-core/clojure/core/30-macros.clj

@@ -187,13 +187,13 @@
 ;; definterface is JVM-only; bind the name to an empty marker.
 (defmacro definterface [name-sym & body] `(def ~name-sym {}))
 
-;; Build a method map {kw (fn* ...)} as an embedded map literal — make-reified
-;; evaluates it (the fn* forms become fns) via build-eval-map, which yields a
-;; struct it can iterate; a (hash-map ...) call would instead yield a phm it can't.
+;; make-reified is a fn (clojure.core); the method map {kw (fn* ...)} is an
+;; ordinary map literal that evaluates to {keyword fn}, and the protocol NAME is
+;; passed as a string (not the symbol) so the call compiles as a plain invoke.
 (defmacro reify [& forms]
   (loop [items (seq forms) proto nil methods {}]
     (if (empty? items)
-      `(make-reified ~proto ~methods)
+      `(make-reified ~(name proto) ~methods)
       (let [x (first items)]
         (if (symbol? x)
           (recur (rest items) (if proto proto x) methods)