Stage2 task2 tier4b (#15)

* core: Stage 2 Task 2 tier 4b — compile ns (+ use/import/refer-clojure)

ns becomes a macro (00-syntax) expanding to (do (in-ns 'name) (require …)
(use …) (import …) (refer-clojure …)) — matching Clojure, where require is
a fn and ns expands to require calls. use/import/refer-clojure join the
namespace ops as ctx-capturing clojure.core fns (use-impl/import-impl/
refer-clojure-impl, interned by install-stateful-fns!). Removed the ns
interpreter special arm; dropped ns/use/import from host_iface special-names
and loader stateful-head?.

Placement matters: ns lives in the FIRST overlay tier (00-syntax), because
the self-hosted analyzer build is triggered while 10-seq loads and processes
jolt.analyzer's own (ns …) form — ns must exist by then. Its body resolves
fn/map/reduce/cond at expansion time, by which point all of 00-syntax has
loaded. The bootstrap compiler (compiler.janet) still PUNTS ns/in-ns/require/
use/import (it compiles analyzer.clj/ir.clj, whose ns forms must fall back to
the interpreter that expands the macro) — only the self-hosted analyzer
compiles them.

use-impl fixes a latent bug: it now refers the used ns's vars into the
CURRENT ns (the old special interned a ns into itself, a no-op).

ns/use/import now compile + interpret as plain invokes. fallback-zero: ns off
must-punt, onto must-compile.

Gate green: conformance 267x3, fallback-zero 38/4, bootstrap-fixpoint
stage1==2==3, self-host, staged-bootstrap, sci-bootstrap, clojure-test-suite
>=4034/67, namespace, deps-loader, cli, aot, embedded-stdlib, uberscript,
features 78/78, all unit + spec.

* test/core: cover ns form + :use; fix use-impl spec parsing

Checking test coverage for the namespace tiers surfaced a real bug nothing
exercised: use-impl checked (array? s) to find a spec's ns symbol, but a
vector spec like [src.x] is a pvec/tuple, not a Janet array — so (:use ...)
and standalone (use ...) errored. Fixed to coerce (pvec->array) then take the
head when the spec is indexed (matching require-impl).

Added coverage that was missing:
- conformance (x3 modes): the (ns …) form itself + :use refers.
- namespaces-spec: (ns …) form, :use, standalone use.

The :use/(use …) path had ZERO tests before, which is why the bug slipped
through earlier tiers.

EBNF needs no change — it's a reader/syntax grammar with no special-forms
enumeration; ns/require/protocol syntax is unchanged (the destructuring note
was already updated in jolt-f79).

Gate green: conformance 269x3, fallback-zero 38/4, self-host, sci-bootstrap,
bootstrap-fixpoint, staged-bootstrap, clojure-test-suite >=4034/67, namespace,
all unit + spec (namespaces 27/27).

---------

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

jolt-core/clojure/core/00-syntax.clj

@@ -36,6 +36,31 @@
     nil
     `(if ~(first clauses) ~(nth clauses 1) (cond ~@(drop 2 clauses)))))
 
+;; ns is sugar over the namespace-op fns (in-ns/require/use/import/refer-clojure,
+;; all ctx-capturing clojure.core fns) — matching Clojure, where require is a fn and
+;; the ns macro expands its clauses into require calls. Each spec is quoted
+;; individually and passed as data; non-list clauses (docstring, attr-map,
+;; :gen-class, …) are ignored. So ns compiles to a plain (do …) of invokes.
+;; MUST live in this first tier: the self-hosted analyzer build (triggered while
+;; 10-seq loads) processes jolt.analyzer's own (ns …) form, so ns has to exist by
+;; then. Its body resolves fn/map/reduce/cond at EXPANSION time, by which point all
+;; of 00-syntax has loaded, so using them here is fine.
+(defmacro ns [nm & clauses]
+  (let [calls (reduce
+                (fn [acc clause]
+                  (if (seq? clause)
+                    (let [head (first clause) args (rest clause)]
+                      (cond
+                        (= head :require) (conj acc `(require ~@(map (fn [s] `(quote ~s)) args)))
+                        (= head :use)     (conj acc `(use ~@(map (fn [s] `(quote ~s)) args)))
+                        (= head :import)  (conj acc `(import ~@(map (fn [s] `(quote ~s)) args)))
+                        (= head :refer-clojure)
+                          (conj acc `(refer-clojure ~@(map (fn [s] `(quote ~s)) args)))
+                        :else acc))
+                    acc))
+                [] clauses)]
+    `(do (in-ns (quote ~nm)) ~@calls)))
+
 ;; Threading: a list form threads x in as the first (->) or last (->>) arg; a bare
 ;; symbol becomes (form x). Recursive; the expand-once cache makes that free.
 (defmacro -> [x & forms]