Stage2 task2 (#13)

* 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).

* 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).

* core: Stage 2 Task 2 tier 3 — compile (var x) + binding

binding keys its thread-binding frame on var cells via (var x), so it
needed (var x) to compile. Added a the-var IR node that emits the embedded
var cell itself (vs var-ref, which derefs):
- ir.clj: the-var node.
- analyzer: 'var' added to handled; analyze-special resolves the symbol to
  its var and emits the-var (uncompilable for a non-var, matching Clojure).
- backend: :the-var emits (quote cell) — the exact per-ctx cell var-get
  keys on, so a compiled binding overrides + restores correctly.
- removed var from loader stateful-head? + host_iface special-names, and
  binding from special-names so it expands+compiles.

Dynamic binding now compiles end-to-end (override/restore, and a compiled
fn reading the dynamic var under the binding) in both modes.

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

---------

Co-authored-by: Yogthos <yogthos@gmail.com>

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)))
 
@@ -181,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)

jolt-core/jolt/analyzer.clj

@@ -14,7 +14,7 @@
   Definitions are ordered so only `analyze` (mutually recursive) is forward
   declared — the bootstrap compiles forward refs through var cells, but keeping
   them to one keeps the compiled namespace simple."
-  (:require [jolt.ir :refer [const local var-ref host-ref if-node do-node invoke
+  (:require [jolt.ir :refer [const local var-ref the-var host-ref if-node do-node invoke
                              def-node let-node fn-node vector-node map-node set-node
                              quote-node throw-node]]
             [jolt.host :refer [form-sym? form-sym-name form-sym-ns form-list?
@@ -28,7 +28,7 @@
 
 (def ^:private handled
   #{"quote" "if" "do" "def" "fn*" "let*" "loop*" "recur" "throw" "try"
-    "syntax-quote"})
+    "syntax-quote" "var"})
 
 (defn- uncompilable [why]
   (throw (str "jolt/uncompilable: " why)))
@@ -163,6 +163,11 @@
     ;; Lower the backtick to construction code (zero runtime cost), then analyze
     ;; it — the macroexpand/compile-time step, per read -> macroexpand -> compile.
     "syntax-quote" (analyze ctx (form-syntax-quote-lower ctx (second items)) env)
+    "var" (let [sym (second items)
+                r (resolve-global ctx sym)]
+            (if (= :var (:kind r))
+              (the-var (:ns r) (:name r))
+              (uncompilable (str "var of non-var " (form-sym-name sym)))))
     (uncompilable (str "special form " op))))
 
 (defn- analyze-symbol [ctx form env]

jolt-core/jolt/ir.clj

@@ -16,6 +16,10 @@
 ;; A global var reference, by name. The back end resolves it to a host var.
 (defn var-ref [ns name] {:op :var :ns ns :name name})
 
+;; The var object itself — (var x) / #'x. Unlike var-ref (which derefs), the back
+;; end emits the embedded var cell so `binding`'s thread-binding frame can key on it.
+(defn the-var [ns name] {:op :the-var :ns ns :name name})
+
 ;; A runtime primitive (cons, +, get, apply, …) the back end maps to the host RT.
 (defn rt [name] {:op :rt :name name})