Compiler research (#10)

adds self-hosted compiler is functionally:
 
- The default compile path is the portable pipeline using jolt.analyzer (Clojure) → host-neutral IR → backend.janet.
- The analyzer is itself Clojure, compiled by jolt for true self-hosting.
- bootstrap-fixpoint passes (stage1 == stage2 == stage3): rebuilding the compiler on its own output.
- clojure.core is now self-hosted in the overlay.
- Stateful forms (defmacro/ns/deftype/defmulti/require/in-ns) are interpreted by design.

test/spec/predicates-spec.janet

@@ -59,6 +59,50 @@
   ["symbol constructor" "(quote x)" "(symbol \"x\")"]
   ["name of string"     "\"s\""  "(name \"s\")"])
 
+# Predicates moved from Janet to the Clojure overlay (jolt-1j0). Jolt has no
+# ratio/bigdecimal types (so ratio?/decimal? are always false, rational?=int?),
+# and no distinct host object/undefined types (object?/undefined? always false).
+(defspec "predicates / overlay-migrated"
+  ["not-any? true"      "true"   "(not-any? even? [1 3 5])"]
+  ["not-any? false"     "false"  "(not-any? even? [1 2 3])"]
+  ["not-every? true"    "true"   "(not-every? even? [2 4 5])"]
+  ["not-every? false"   "false"  "(not-every? even? [2 4 6])"]
+  ["ident? number"      "false"  "(ident? 1)"]
+  ["qualified-ident?"   "true"   "(qualified-ident? :a/b)"]
+  ["qualified-ident? no" "false" "(qualified-ident? :a)"]
+  ["simple-ident?"      "true"   "(simple-ident? :a)"]
+  ["ratio?"             "false"  "(ratio? 3)"]
+  ["decimal?"           "false"  "(decimal? 3)"]
+  ["rational? int"      "true"   "(rational? 3)"]
+  ["rational? float"    "false"  "(rational? 3.5)"]
+  ["nat-int? zero"      "true"   "(nat-int? 0)"]
+  ["nat-int? neg"       "false"  "(nat-int? -1)"]
+  ["pos-int?"           "true"   "(pos-int? 5)"]
+  ["neg-int?"           "true"   "(neg-int? -3)"]
+  ["NaN? on nan"        "true"   "(NaN? (/ 0.0 0.0))"]
+  ["NaN? on number"     "false"  "(NaN? 5)"]
+  ["abs negative"       "3"      "(abs -3)"]
+  ["abs positive"       "2.5"    "(abs 2.5)"]
+  ["object?"            "false"  "(object? 1)"]
+  ["undefined?"         "false"  "(undefined? 1)"]
+  ["keyword-identical?" "true"   "(keyword-identical? :a :a)"]
+  ["keyword-identical? no" "false" "(keyword-identical? :a :b)"])
+
+# Tagged-value predicates moved to the overlay in Phase 4 (read the value's
+# :jolt/type via get). The constructors stay native.
+(defspec "predicates / tagged-value (Phase 4)"
+  ["atom? yes"          "true"   "(atom? (atom 1))"]
+  ["atom? no"           "false"  "(atom? 1)"]
+  ["volatile? yes"      "true"   "(volatile? (volatile! 1))"]
+  ["volatile? no"       "false"  "(volatile? (atom 1))"]
+  ["record? yes"        "true"   "(do (defrecord Rp [a]) (record? (->Rp 1)))"]
+  ["record? no map"     "false"  "(record? {:a 1})"]
+  ["record? no nil"     "false"  "(record? nil)"]
+  ["tagged-literal? yes" "true"  "(tagged-literal? (tagged-literal (quote inst) \"2020\"))"]
+  ["tagged-literal? no" "false"  "(tagged-literal? 1)"]
+  ["reader-conditional? no" "false" "(reader-conditional? 1)"]
+  ["chunked-seq? always false" "false" "(chunked-seq? (seq [1 2 3]))"])
+
 (defspec "predicates / equality & identity"
   ["= same"             "true"   "(= 1 1)"]
   ["= vectors"          "true"   "(= [1 2] [1 2])"]