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>

src/jolt/compiler.janet

@@ -159,7 +159,7 @@
              "defmethod" "prefer-method" "remove-method" "remove-all-methods"
              "get-method" "methods"
              "satisfies?" "instance?" "set!" "var" "var-get"
-             "var-set" "var?" "in-ns" "ns" "require" "create-ns" "remove-ns"
+             "var-set" "var?" "ns" "create-ns" "remove-ns"
              "find-ns" "all-ns" "the-ns" "find-var" "intern" "resolve"
              "ns-resolve" "ns-aliases" "ns-imports" "ns-interns"
              "alter-var-root" "alter-meta!" "reset-meta!" "locking" "new"

src/jolt/evaluator.janet

@@ -751,6 +751,27 @@
   (each p pairs (put (obj :jolt/protocol-methods) (in p 0) (in p 1)))
   obj)
 
+(defn require-impl
+  "(require '[ns :as a :refer [...]] ...) — load + alias/refer each spec. A fn, so
+  the args (quoted specs) arrive evaluated. Varargs (Clojure-compatible); each spec
+  is a vector. eval-require does the namespace load + alias/refer into current-ns."
+  [ctx & specs]
+  (each spec specs
+    (let [s (if (pvec? spec) (pv->array spec) spec)]
+      (if (and (indexed? s) (> (length s) 0))
+        (eval-require ctx s)
+        (error "require expects a vector spec"))))
+  nil)
+
+(defn in-ns-impl
+  "(in-ns 'foo) — switch the current namespace (creating it if needed). A fn; the
+  quoted symbol arrives evaluated."
+  [ctx sym]
+  (def ns-name (if (and (struct? sym) (= :symbol (sym :jolt/type))) (sym :name) (string sym)))
+  (ctx-find-ns ctx ns-name)
+  (ctx-set-current-ns ctx ns-name)
+  nil)
+
 (defn install-stateful-fns!
   "Intern ctx-capturing closures for the stateful primitives into clojure.core, so
   both the interpreter and the compiler reach them as ordinary fns. Called by
@@ -766,6 +787,8 @@
       (register-method-impl ctx type-name proto-name method-name f)))
   (ns-intern core "make-reified"
     (fn [proto-name methods-map] (make-reified-impl ctx proto-name methods-map)))
+  (ns-intern core "require" (fn [& specs] (require-impl ctx ;specs)))
+  (ns-intern core "in-ns" (fn [sym] (in-ns-impl ctx sym)))
   core)
 
 # Dispatch a special form by its string name.
@@ -972,11 +995,8 @@
                                 (set i (+ i 1)))
                       (do (set result clause) (++ i)))))))
            result)
-    "require" (let [spec0 (eval-form ctx bindings (in form 1))
-                    spec (if (pvec? spec0) (pv->array spec0) spec0)]
-                 (if (and (indexed? spec) (> (length spec) 0))
-                   (eval-require ctx spec)
-                   (error "require expects a vector spec")))
+    # require / in-ns are now ordinary clojure.core fns (install-stateful-fns!) —
+    # no special-form arm; they compile + interpret as plain invokes.
     "all-ns" (all-ns ctx)
     "the-ns" (the-ns ctx)
     "create-ns" (create-ns ctx (sym-name-str (in form 1)))
@@ -985,11 +1005,6 @@
     "ns-aliases" (let [ns (ctx-find-ns ctx (ctx-current-ns ctx))] (ns :aliases))
     "ns-imports" (let [ns (ctx-find-ns ctx (ctx-current-ns ctx))] (ns :imports))
     "ns-resolve" (ns-resolve (ctx-find-ns ctx (ctx-current-ns ctx)) (in form 1))
-    "in-ns" (let [sym (eval-form ctx bindings (in form 1))
-                  ns-name (if (and (struct? sym) (= :symbol (sym :jolt/type))) (sym :name) (string sym))]
-              (ctx-find-ns ctx ns-name)
-              (ctx-set-current-ns ctx ns-name)
-              nil)
     "resolve" (let [sym (eval-form ctx bindings (in form 1))]
                 (if (and (struct? sym) (= :symbol (sym :jolt/type)))
                   (let [r (protect (resolve-var ctx bindings sym))]

src/jolt/host_iface.janet

@@ -82,7 +82,8 @@
              # ns-management forms dispatched by the interpreter (not core vars)
              "create-ns" "remove-ns" "find-ns" "all-ns" "the-ns" "resolve"
              "ns-resolve" "ns-aliases" "ns-imports" "ns-interns"
-             "read-string" "macroexpand-1" "defonce" "ns" "in-ns" "require"
+             # require/in-ns are now clojure.core fns (compile as plain invokes).
+             "read-string" "macroexpand-1" "defonce" "ns"
              "import" "use" "refer" "defrecord"
              # defprotocol/extend-type/extend-protocol/reify now expand to plain
              # def + protocol-dispatch/register-method/make-reified invokes.

src/jolt/loader.janet

@@ -15,7 +15,6 @@
 (defn- stateful-head? [head-name]
   (or (= head-name "defmacro") (= head-name "ns")
       (= head-name "deftype") (= head-name "defmulti") (= head-name "defmethod")
-      (= head-name "require") (= head-name "in-ns")
       (= head-name "set!")
       (= head-name ".") (= head-name "new")
       (= head-name "eval")))