self-host: working portable analyzer -> IR -> Janet back end pipeline

The Clojure-in-Clojure front end now compiles and runs a real subset end to end:
arithmetic, if/do/let, vector/map literals, def + name-based global refs, fn,
defn (via macroexpand), recursion through the var cell, multi-arity, variadic,
and higher-order calls. Proven by test/integration/self-host-test.janet.

Pieces:
- jolt-core/jolt/analyzer.clj — PORTABLE Clojure analyzer: reader form -> IR,
  depending only on the host contract (jolt.host), never on Janet.
- src/jolt/host_iface.janet — Janet impl of the jolt.host contract (form
  introspection + resolve/macro/current-ns), installed into each ctx.
- src/jolt/backend.janet — Janet back end: IR -> Janet form -> eval; resolves
  name-based :var nodes to cells and reuses runtime helpers.

Host Janet code lives in src/jolt/ (not a host/janet/ dir): Janet resolves
relative imports per file, so cross-dir ../../src/jolt/* imports load second
instances of compiler/types/core and corrupt state. The portability boundary is
the jolt.host namespace contract + jolt-core/, not the directory.

Notes: gensym in the back end must not be Janet's (shadowed by Jolt's via use);
a jolt bug — (into #{} coll) doesn't add elements — was worked around with reduce
conj in the analyzer (filed separately).

test/integration/self-host-test.janet

@@ -0,0 +1,48 @@
+# End-to-end proof of the self-hosting pipeline: a reader form is analyzed by the
+# PORTABLE Clojure analyzer (jolt.analyzer, in jolt-core) into host-neutral IR,
+# then the Janet back end lowers the IR to a Janet form and evaluates it. No use
+# of compiler.janet's analyzer — this is the Clojure-in-Clojure front end.
+(import ../../src/jolt/backend :as backend)
+(use ../../src/jolt/api)
+(use ../../src/jolt/reader)
+
+(defn ce [ctx s] (normalize-pvecs (backend/compile-and-eval ctx (parse-string s))))
+
+(print "self-host pipeline (Clojure analyzer -> IR -> Janet)...")
+(let [ctx (init)]
+  # primitives + control flow
+  (assert (= 3 (ce ctx "(+ 1 2)")) "+")
+  (assert (= 6 (ce ctx "(* 2 3)")) "*")
+  (assert (= :a (ce ctx "(if true :a :b)")) "if true")
+  (assert (= :b (ce ctx "(if false :a :b)")) "if false")
+  (assert (= 10 (ce ctx "(let [x 4 y 6] (+ x y))")) "let")
+  (assert (= 6 (ce ctx "(do 1 2 6)")) "do")
+
+  # literals
+  (assert (= [2 3 4] (ce ctx "(map inc [1 2 3])")) "vector literal + core fn")
+  (assert (= 1 (ce ctx "(get {:a 1 :b 2} :a)")) "map literal")
+  (assert (= 42 (ce ctx "(quote 42)")) "quote literal")
+
+  # def + global reference (name-based var resolution)
+  (ce ctx "(def base 100)")
+  (assert (= 142 (ce ctx "(+ base 42)")) "def + later ref")
+
+  # fn / defn (defn is a macro -> expand -> def of fn*)
+  (ce ctx "(defn add [a b] (+ a b))")
+  (assert (= 7 (ce ctx "(add 3 4)")) "defn")
+  (assert (= 49 (ce ctx "((fn [x] (* x x)) 7)")) "anon fn")
+
+  # recursion through the var cell (no recur needed)
+  (ce ctx "(defn fib [n] (if (< n 2) n (+ (fib (- n 1)) (fib (- n 2)))))")
+  (assert (= 55 (ce ctx "(fib 10)")) "recursive fib via var")
+
+  # multi-arity + variadic
+  (ce ctx "(defn arity ([a] a) ([a b] (+ a b)) ([a b & more] (apply + a b more)))")
+  (assert (= 5 (ce ctx "(arity 5)")) "multi-arity 1")
+  (assert (= 7 (ce ctx "(arity 3 4)")) "multi-arity 2")
+  (assert (= 15 (ce ctx "(arity 1 2 3 4 5)")) "multi-arity variadic")
+
+  # higher-order + nesting
+  (assert (= 15 (ce ctx "(reduce + (map inc [0 1 2 3 4]))")) "reduce+map"))
+
+(print "self-host pipeline passed!")