spec.alpha: reify ILookup get, NPE/CCE, quoted #inst/#uuid, anon-fn class, kwargs map

Close clojure.spec.alpha's remaining gaps — its conform/explain/describe/multi-spec
suite (clojure.test-clojure.spec, multi-spec) now passes fully.

- (get reify k) / (:k reify) routes to a reify's clojure.lang.ILookup valAt. spec
  reifies fspec/regex specs as ILookup and reads (:args spec) off them, so before
  this instrument never saw the args spec.
- A failed numeric comparison reports the JVM class: a nil operand is
  NullPointerException, a non-number is ClassCastException (was an opaque :object
  condition). conform-explain checks the thrown class.
- A quoted / macro-form #inst / #uuid literal constructs its Date/UUID value, like
  the JVM reader (which builds it at read time). emit-quoted was emitting the raw
  tagged form, so #inst "1939" and #inst "1939-01-01T00:00:00.000-00:00" weren't =.
- An anonymous fn reports class clojure.lang.AFunction$fn (the $fn marker), so
  spec's fn-sym returns ::s/unknown for it, matching the JVM's ns$fn__N.
- A fn with & {:as m} kwargs accepts a trailing map (Clojure 1.11): (f :a 1 {:b 2})
  and (f {:a 1}) both bind m, by merging an odd trailing map over the pairs.
- A thread responds to .getStackTrace (empty — jolt does TCO).

clojure.test-clojure.instr does not fully pass: its ::caller assertions need the
calling fn's stack frame, which TCO erases (an inherent host divergence, like the
JVM keeping tail frames).

make test green (+4 corpus rows, 0 new divergences), shakesmoke byte-identical.
Re-mint (backend emit-quoted + the destructure macro).

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

@@ -212,16 +212,16 @@
                  (let* [g (symbol (str (gensym)))
                         gm (symbol (str (gensym)))
                         ;; kwargs: a map pattern may bind against the sequential rest
-                        ;; of a fn — (& {:keys [...]}) — which is a seq of alternating
-                        ;; k/v args, or a single trailing map. Coerce like Clojure (and
-                        ;; like the interpreter's destructure-bind, so interpret/compile
-                        ;; agree): a sequential value with one map element is that map,
-                        ;; otherwise (apply hash-map). A real map value is used as-is, so
-                        ;; ordinary map destructuring is unaffected. g holds init once;
-                        ;; gm is the coerced map every lookup (and :as) reads from.
+                        ;; of a fn — (& {:keys [...]}) — a seq of alternating k/v args,
+                        ;; optionally with a trailing map (Clojure 1.11: (f :a 1 {:b 2})
+                        ;; merges the map over the pairs; (f {:a 1}) is just the map).
+                        ;; An odd count means the last arg is that trailing map. A real
+                        ;; map value is used as-is, so ordinary map destructuring is
+                        ;; unaffected. g holds init once; gm is the coerced map every
+                        ;; lookup (and :as) reads from.
                         coerce `(if (sequential? ~g)
-                                  (if (and (= 1 (count ~g)) (map? (first ~g)))
-                                    (first ~g)
+                                  (if (odd? (count ~g))
+                                    (merge (apply hash-map (butlast ~g)) (last ~g))
                                     (apply hash-map ~g))
                                   ~g)
                         or-map (get pat :or)

jolt-core/jolt/backend_scheme.clj

@@ -12,7 +12,8 @@
                                form-list? form-vec? form-map? form-set? form-char?
                                form-literal? form-elements form-vec-items
                                form-map-pairs form-set-items form-char-code
-                               form-regex? form-regex-source]]))
+                               form-regex? form-regex-source
+                               form-inst? form-inst-source form-uuid? form-uuid-source]]))
 
 ;; Hot clojure.core primitives lowered to native Scheme.
 ;; `=` is the exactness-aware jolt= from values.ss; inc/dec/
@@ -335,6 +336,11 @@
     (form-map? form) (emit-quoted-map (form-map-pairs form))
     ;; a quoted #"…" regex value -> reconstruct it (same as the :regex IR leaf).
     (form-regex? form) (str "(jolt-regex " (chez-str-lit (form-regex-source form)) ")")
+    ;; quoted #inst / #uuid literals construct their value, like the JVM reader
+    ;; (which builds the Date/UUID at read time, so a quoted/macro form carries the
+    ;; value, not the raw tagged form). Same emit as the :inst / :uuid IR leaves.
+    (form-inst? form) (str "(jolt-inst-from-string " (chez-str-lit (form-inst-source form)) ")")
+    (form-uuid? form) (str "(jolt-uuid-from-string " (chez-str-lit (form-uuid-source form)) ")")
     ;; plain jolt VALUES (metadata maps and anything nested in them)
     (map? form) (emit-quoted-map-value form)
     (vector? form) (str "(jolt-vector " (str/join " " (map emit-quoted form)) ")")