core: Stage 2 Task 2 tier 2a — compile defprotocol/extend-type/extend-protocol

Applies the proven enabler: stateful primitives become per-ctx closures
captured over ctx, interned in clojure.core (install-stateful-fns!), so
they resolve + compile as plain :var invokes and work for deferred calls.

- protocol-dispatch / register-method: extracted from the interpreter
  special handlers into ctx-taking impls (protocol-dispatch-impl /
  register-method-impl) + interned as ctx-capturing clojure.core fns.
  Removed their special-symbol? entries + handler arms, and dropped them
  from host_iface special-names + compiler uncompilable-heads.
- defprotocol/extend-type/extend-protocol macros now pass the protocol/
  method/type NAMES as strings (not symbols), so the emitted calls compile
  as ordinary invokes; removed the three macros from special-names so the
  analyzer expands+compiles them instead of punting to the interpreter.
- Both interpreter and compiled paths now call the same ctx-capturing
  closures (one dispatch implementation, no special-form duplication).

reify/make-reified deferred to tier 2b (map-eval shape); defrecord 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/7, multimethods 9/9).

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

@@ -161,12 +161,18 @@
        (def ~pname (make-protocol ~(name pname) ~methods))
        ~@(map (fn [sig]
                 `(def ~(first sig)
-                   (fn* [this# & rest#] (protocol-dispatch ~pname ~(first sig) this# rest#))))
+                   ;; protocol-dispatch is a fn (clojure.core); pass the protocol /
+                   ;; method NAMES as strings (not the symbols) so it compiles as a
+                   ;; plain invoke rather than evaluating the symbols as vars.
+                   (fn* [this# & rest#]
+                     (protocol-dispatch ~(name pname) ~(name (first sig)) this# rest#))))
               sigs))))
 
 (defmacro extend-type [tsym psym & impls]
+  ;; register-method is a fn (clojure.core); pass type/protocol/method NAMES as
+  ;; strings (not the symbols) so the call compiles as a plain invoke.
   `(do ~@(map (fn [spec]
-                `(register-method ~tsym ~psym ~(first spec)
+                `(register-method ~(name tsym) ~(name psym) ~(name (first spec))
                                   (fn* ~(nth spec 1) ~@(drop 2 spec))))
               impls)))