core: Stage 2 Task 2 tier 4a — compile require + in-ns (#14)

require/in-ns take quoted (already-evaluated) args, so they become ordinary
ctx-capturing clojure.core fns (install-stateful-fns!):
- require-impl (varargs over specs -> eval-require) / in-ns-impl, extracted
  from the eval-list special arms.
- removed their eval-list match arms (they fall through to the function-call
  default, resolving the interned closures) and dropped them from
  host_iface special-names + loader stateful-head? + compiler
  uncompilable-heads.

require+alias+refer and in-ns now compile + interpret as plain invokes.

Tests: namespace-test uses bare make-ctx, so it now installs the stateful
fns via a fresh-ctx helper (api/init does this automatically). fallback-zero
moves require off must-punt and adds require/in-ns/defprotocol/extend-type/
reify/(var map) to must-compile (37 now); deftype takes require's must-punt
slot.

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

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

test/integration/fallback-zero-test.janet

@@ -42,13 +42,20 @@
    "(def answer 42)" "(map inc [1 2 3])" "(reduce + 0 [1 2 3])"
    "(get {:a 1} :a)" "(vec (range 5))"
    # set?/disj are plain fns now, not special forms (jolt-g3h)
-   "(set? #{1 2})" "(disj #{1 2 3} 2)"])
+   "(set? #{1 2})" "(disj #{1 2 3} 2)"
+   # Stage 2 (jolt-eaa): stateful forms moved onto the compile path. (binding only
+   # compiles over an INTERNED var; the built-in dynamic vars aren't interned yet,
+   # so it's exercised end-to-end in the state spec instead.)
+   "(require (quote [clojure.string :as s]))" "(in-ns (quote foo.bar))"
+   "(defprotocol P (m [x]))" "(extend-type Long P (m [x] x))"
+   "(reify P (m [this] 1))" "(var map)"])
 
 # --- Intentional fallback (sanity sample): these SHOULD punt to the interpreter.
-# Not the frozen set (that's Task 2) — just a few to confirm the boundary holds
-# in the punt direction so the harness can't pass by compiling everything.
+# 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.
 (def must-punt
-  ["(ns foo.bar)" "(defmacro m [x] x)" "(require (quote [clojure.string]))"
+  ["(ns foo.bar)" "(defmacro m [x] x)" "(deftype T [a])"
    "(set! *warn-on-reflection* true)" "(letfn [(f [n] (g n)) (g [n] (f n))] (f 1))"])
 
 (var fails @[])

test/integration/namespace-test.janet

@@ -2,21 +2,28 @@
 (use ../../src/jolt/types)
 (use ../../src/jolt/evaluator)
 
+# 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))
+
 # Helper: parse and eval in a fresh ctx
 (defn eval-str [s]
-  (let [ctx (make-ctx)
+  (let [ctx (fresh-ctx)
         form (parse-string s)]
     (eval-form ctx @{} form)))
 
 (print "1: in-ns...")
-(let [ctx (make-ctx)]
+(let [ctx (fresh-ctx)]
   (def form (parse-string "(in-ns 'my.app)"))
   (eval-form ctx @{} form)
   (assert (= "my.app" (ctx-current-ns ctx)) "in-ns switches namespace"))
 (print "  passed")
 
 (print "2: def in different namespace...")
-(let [ctx (make-ctx)]
+(let [ctx (fresh-ctx)]
   (eval-form ctx @{} (parse-string "(in-ns 'my.app)"))
   (eval-form ctx @{} (parse-string "(def x 42)"))
   (let [ns (ctx-find-ns ctx "my.app")
@@ -25,13 +32,13 @@
 (print "  passed")
 
 (print "3: ns form...")
-(let [ctx (make-ctx)]
+(let [ctx (fresh-ctx)]
   (eval-form ctx @{} (parse-string "(ns my.lib)"))
   (assert (= "my.lib" (ctx-current-ns ctx)) "ns sets current namespace"))
 (print "  passed")
 
 (print "4: ns with require...")
-(let [ctx (make-ctx)]
+(let [ctx (fresh-ctx)]
   # Set up a namespace with some vars
   (let [other-ns (ctx-find-ns ctx "other.lib")]
     (ns-intern other-ns "f" (fn [x] (inc x))))
@@ -46,7 +53,7 @@
 (print "  passed")
 
 (print "5: require form (standalone)...")
-(let [ctx (make-ctx)]
+(let [ctx (fresh-ctx)]
   (eval-form ctx @{} (parse-string "(require '[other.lib :as o])"))
   (let [ns (ctx-find-ns ctx "user")
         aliased (ns-import-lookup ns "o")]
@@ -54,7 +61,7 @@
 (print "  passed")
 
 (print "6: qualified symbol via alias...")
-(let [ctx (make-ctx)]
+(let [ctx (fresh-ctx)]
   # Set up target ns
   (let [target (ctx-find-ns ctx "other.lib")]
     (ns-intern target "f" (fn [x] (inc x))))
@@ -68,7 +75,7 @@
 (print "  passed")
 
 (print "7: require then use alias...")
-(let [ctx (make-ctx)]
+(let [ctx (fresh-ctx)]
   # Set up target ns
   (let [target (ctx-find-ns ctx "math.lib")]
     (ns-intern target "add" (fn [a b] (+ a b))))
@@ -79,7 +86,7 @@
 (print "  passed")
 
 (print "8: ns form requires multiple...")
-(let [ctx (make-ctx)]
+(let [ctx (fresh-ctx)]
   (let [ns1 (ctx-find-ns ctx "a.lib")]
     (ns-intern ns1 "f" (fn [x] (inc x))))
   (let [ns2 (ctx-find-ns ctx "b.lib")]