core: close the compile-path gaps that broke uberscripting Selmer + config

Loading these libs via require worked (load-ns-source interprets, macros
expand lazily) but the same code inlined by uberscript routes through
eval-toplevel and compiled, surfacing four gaps:

- a ^{:map} metadata def name reads as (def (with-meta name m) v); the
  analyzer died extracting the name (config.core's defonce env). It now
  throws uncompilable so the interpreter, which handles it, takes over.
- declare was a no-op, so a compiled forward reference to a declared
  name that collides with a janet root binding bound to the host fn
  (selmer.parser's (declare parse) compiled to janet's 1-arg parse).
  declare now expands to no-init defs, the interpreter interns them,
  and the analyzer routes no-init def to the interpreter.
- class? was missing (selmer.util's exception macro calls it at
  expansion time). Always false, like ratio? — no Class objects here.
- require of an unlocatable namespace silently left an empty ns behind,
  deferring the failure to an unresolved symbol far from the cause. It
  now throws like Clojure's FileNotFoundException. Namespaces entered
  in-session count as loaded (Clojure puts them in *loaded-libs*), and
  the SCI bootstrap opts out via :lenient-require? since its
  clj-targeted requires can't all exist on this host.

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

@@ -116,9 +116,12 @@
                      `(~form ~x))]
       `(->> ~threaded ~@(rest forms)))))
 
-;; Forward declaration is a no-op on Jolt — the compiler resolves forward refs via
-;; pending cells (matching the prior Janet macro).
-(defmacro declare [& syms] `(do))
+;; Forward declaration interns unbound vars (Clojure semantics). The interpreter
+;; resolves forward refs lazily either way, but the COMPILER classifies globals at
+;; compile time: without the var, a declared name that collides with a Janet root
+;; binding (parse, hash, …) would compile to the host fn instead of the var.
+(defmacro declare [& syms]
+  `(do ~@(map (fn* [s] `(def ~s)) syms)))
 
 ;; destructure — Clojure's binding-vector expander, ported from the Janet seed
 ;; (was core-destructure). Turns a binding vector that may contain destructuring

jolt-core/clojure/core/20-coll.clj

@@ -83,6 +83,9 @@
 ;; Jolt has no ratio or bigdecimal types, so these are constants / reduce to int?.
 (defn ratio? [x] false)
 (defn decimal? [x] false)
+;; No first-class Class objects either: class names are symbols the evaluator
+;; handles in instance?/new positions, never values — so nothing is a class.
+(defn class? [x] false)
 (defn rational? [x] (int? x))
 (defn nat-int? [x] (and (int? x) (>= x 0)))
 (defn neg-int? [x] (and (int? x) (neg? x)))

jolt-core/jolt/analyzer.clj

@@ -140,11 +140,19 @@
                     (const nil)))
     "do" (analyze-seq ctx (rest items) env)
     "throw" (throw-node (analyze ctx (nth items 1) env))
-    "def" (let [name-sym (nth items 1)
-                nm (form-sym-name name-sym)
-                cur (compile-ns ctx)]
-            (host-intern! ctx cur nm)
-            (def-node cur nm (analyze ctx (nth items 2) env) (form-sym-meta name-sym)))
+    "def" (let [name-sym (nth items 1)]
+            ;; ^{:map} metadata reads as (def (with-meta name m) v) — the
+            ;; metadata is a runtime expression, so the interpreter evaluates
+            ;; the whole def (it unwraps the name and merges the meta).
+            (when-not (form-sym? name-sym)
+              (uncompilable "def name with map metadata"))
+            ;; (def name) with no init (declare) just interns — interpreter's job
+            (when (< (count items) 3)
+              (uncompilable "def with no init"))
+            (let [nm (form-sym-name name-sym)
+                  cur (compile-ns ctx)]
+              (host-intern! ctx cur nm)
+              (def-node cur nm (analyze ctx (nth items 2) env) (form-sym-meta name-sym))))
     "let*" (let [bvec (vec (form-vec-items (nth items 1)))
                  r (analyze-bindings ctx bvec env)]
              (let-node (first r) (analyze-seq ctx (drop 2 items) (second r))))