Stage2 task2 tier5 (#16)

* core: Stage 2 Task 2 tier 5a — compile defmulti + defmethod

defmulti/defmethod become macros (30-macros) over ctx-capturing
clojure.core fns (defmulti-setup/defmethod-setup, interned by
install-stateful-fns!):
- defmulti: (defmulti name dispatch & opts) -> (defmulti-setup 'name
  dispatch ~@opts). name quoted; dispatch + opts (:default/:hierarchy)
  evaluated. defmulti-setup builds the dispatch closure over the method
  table and interns the var (same hierarchy/default/cache behavior).
- defmethod: (defmethod mm dval & fn-tail) -> (defmethod-setup 'mm dval
  (fn ~@fn-tail)). The method impl is now a COMPILED (fn …) (was an
  interpreted fn* eval). Auto-creates the multimethod if missing.
- removed their special-symbol? entries + eval-list arms, and dropped them
  from host_iface special-names + loader stateful-head?.

Both compile + interpret as plain invokes; dispatch incl. :default and
derive/hierarchy works in both modes.

Tests: evaluator-test (defmulti case) + namespace-test now use init (these
forms are overlay macros now, so a bare make-ctx lacks them).

Gate green: conformance 269x3, fallback-zero 38/4, bootstrap-fixpoint
stage1==2==3, self-host, staged-bootstrap, sci-bootstrap, clojure-test-suite
>=4034/67, features 78/78, all unit + spec (multimethods 16/16).

* core: Stage 2 Task 2 tier 5b — compile deftype + defrecord

deftype becomes a macro (30-macros) over make-deftype-ctor (a ctx-capturing
clojure.core fn that bakes the ns-qualified type tag at def time) plus
extend-type for any inline protocol methods — so it compiles as a plain (do …).
Mirrors defrecord's existing field-let/protocol-grouping pattern.
- make-deftype-ctor-impl (evaluator) builds the ctor; interned as a closure.
- removed the deftype special-symbol? entry + eval-list arm; dropped deftype/
  defrecord from host_iface special-names + loader stateful-head?.
- defrecord no longer redefines ->name via (Name. …) interop (frozen) — deftype
  already provides ->name, so defrecord compiles too (map->name builds via it).
- field-kws spliced into a vector LITERAL ([~@…]) so the analyzer sees a vector
  form, not a runtime pvec; type name + fields are unwrapped of ^meta (the reader
  yields (with-meta sym m) forms, e.g. sci's (deftype ^{:doc …} Var …)).

With tier 5a, all of deftype/defrecord/defmulti/defmethod compile. The loader's
interpret-only set is now just the frozen host-coupled forms: defmacro/set!/./
new/eval.

Tests: evaluator-test deftype case uses init (deftype is an overlay macro now);
fallback-zero moves deftype off must-punt, adds deftype/defrecord/defmulti/
defmethod to must-compile (43/3).

Gate green (full jpm build + jpm test): conformance 269x3, fallback-zero 43/3,
bootstrap-fixpoint stage1==2==3, self-host, staged-bootstrap, sci-bootstrap
422/0, clojure-test-suite >=4034/67, all unit + spec.

---------

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

test/integration/fallback-zero-test.janet

@@ -49,14 +49,16 @@
    "(require (quote [clojure.string :as s]))" "(in-ns (quote foo.bar))"
    "(ns foo.bar (:require [clojure.string :as s]))"
    "(defprotocol P (m [x]))" "(extend-type Long P (m [x] x))"
-   "(reify P (m [this] 1))" "(var map)"])
+   "(reify P (m [this] 1))" "(var map)"
+   # Stage 2 tier 5: type/dispatch definitional forms compile too
+   "(deftype Pt [x y])" "(deftype Sq [s] P (m [this] s))"
+   "(defrecord Rec [a b])" "(defmulti mf :k)" "(defmethod mf :a [x] x)"])
 
 # --- Intentional fallback (sanity sample): these SHOULD punt to the interpreter.
-# Shrinking as Stage 2 (jolt-eaa) moves stateful forms onto the compile path
-# (require/in-ns/protocols/binding now compile). The remaining frozen/uncompiled
-# set keeps the harness honest in the punt direction.
+# The remaining frozen/uncompiled set keeps the harness honest in the punt
+# direction: defmacro + set! (frozen host-coupled), and letfn (needs letrec IR).
 (def must-punt
-  ["(defmacro m [x] x)" "(deftype T [a])"
+  ["(defmacro m [x] x)"
    "(set! *warn-on-reflection* true)" "(letfn [(f [n] (g n)) (g [n] (f n))] (f 1))"])
 
 (var fails @[])

test/integration/namespace-test.janet

@@ -1,13 +1,12 @@
 (use ../../src/jolt/reader)
 (use ../../src/jolt/types)
 (use ../../src/jolt/evaluator)
+(import ../../src/jolt/api :as api)
 
-# in-ns/require are now ordinary clojure.core fns (Stage 2 jolt-eaa), interned by
-# install-stateful-fns! — api/init does this; a bare make-ctx must do it too.
-(defn- fresh-ctx []
-  (let [ctx (make-ctx)]
-    (install-stateful-fns! ctx)
-    ctx))
+# ns/in-ns/require/use are overlay macros + clojure.core fns now (Stage 2 jolt-eaa),
+# so these interpreter tests need the full env (init loads the overlay + installs
+# the stateful fns), not a bare make-ctx.
+(defn- fresh-ctx [] (api/init))
 
 # Helper: parse and eval in a fresh ctx
 (defn eval-str [s]

test/unit/evaluator-test.janet

@@ -111,7 +111,9 @@
 (print "  passed")
 
 (print "15: defmulti/defmethod...")
-(let [ctx (make-ctx)]
+# defmulti/defmethod are overlay macros now (Stage 2 jolt-eaa), so this needs the
+# full env (init loads the overlay + installs the *-setup fns), not a bare make-ctx.
+(let [ctx (init)]
   (eval-form ctx @{} (parse-string "(defmulti my-dispatch (fn* [x] (x :type)))"))
   (eval-form ctx @{} (parse-string "(defmethod my-dispatch :foo [_] :got-foo)"))
   (eval-form ctx @{} (parse-string "(defmethod my-dispatch :bar [_] :got-bar)"))
@@ -120,7 +122,8 @@
 (print "  passed")
 
 (print "16: deftype...")
-(let [ctx (make-ctx)
+# deftype is an overlay macro now (Stage 2 jolt-eaa) — needs the full env (init).
+(let [ctx (init)
       _ (eval-form ctx @{} (parse-string "(deftype Point [x y])"))
       _ (eval-form ctx @{} (parse-string "(def p (Point. 10 20))"))
       p-val (eval-form ctx @{} (parse-string "p"))