Jank derived spec tests (#17)

* test: adapt jank's form/reader tests into spec suites; fix case no-match

Vendoring jank's behavior (not the project): we base our own copies on the
jank test corpus to close coverage gaps, but maintain them ourselves since
jank may diverge. Two new spec batteries (jank-isms translated to Jolt:
letfn* -> letfn, jank catch types -> :default; platform-specific bigdec/
biginteger/ratio/uuid/##Inf/unicode cases omitted):

- test/spec/forms-spec.janet (52): case, fn (arity/variadic/closure/recur/
  named), let, letfn, loop, try, if/do/def/call — incl :throws regression
  cases (no-match, bad params, nil call).
- test/spec/reader-forms-spec.janet (22): #() (% %N %&), #' var-quote,
  ^metadata, syntax-quote (gensym/unquote/splice).

Fix surfaced by adaptation: case with no matching clause and no default now
throws 'No matching clause' (Clojure semantics) instead of returning nil
(00-syntax). Gate green incl full jpm build+test.

Other gaps the adaptation surfaced are filed (tests adjusted to jolt's
current behavior + a comment, not silently dropped):
  jolt-vdo case duplicate test constants not rejected
  jolt-w2v loop bindings not sequential (later init can't see earlier)
  jolt-6x1 #() %& miscomputes arity with a higher positional (%2 …)
  jolt-xl0 ^meta not attached to collection literals ({}/[]/#{})
  jolt-265 syntax-quote doesn't fully-qualify core syms to clojure.core/
  jolt-edb syntax-quote ~/~@ not processed inside set literals

* core: fix 5 Clojure-conformance gaps surfaced by jank tests

All from adapting jank's form/reader tests; each fix verified in interpret +
compile modes and the spec tests now assert the correct behavior.

- jolt-vdo: case now rejects duplicate test constants at expansion (Clojure
  compile error), via bootstrap-safe duplicate detection (00-syntax; analyzer.clj
  uses case during its own build, so seed-only fns).
- jolt-w2v: loop bindings are now sequential like let — a later init can
  reference an earlier binding. Fixed the interpreter loop* (accumulating scope)
  and the back end emit-loop (bind initial inits in a sequential Janet let before
  entering the recur target).
- jolt-6x1: #() reader computes the fixed arity from the MAX positional (%2 ->
  [p1 p2 & rest]); % and %1 unify; unused lower slots get placeholder params.
- jolt-xl0: ^meta on collection literals ({}/[]/#{}) now attaches — read-meta
  passes the NORMALIZED metadata map to with-meta (was the raw meta-form).
- jolt-edb: syntax-quote processes ~/~@ inside set literals (new __sqset builder
  in core + set branches in syntax-quote* and syntax-quote-lower).

Deferred: jolt-265 (fully-qualify core syms to clojure.core/ in syntax-quote) —
it passes conformance but breaks the standalone uberscript (the ns macro emits
unqualified require/in-ns, which then qualify and break bundled require/alias).
Reverted to bare (functionally resolves); re-opened with the finding.

Gate green incl full jpm build + jpm test: conformance 269x3, suite >=4034/67,
fixpoint, self-host, sci 422/0, uberscript, all unit + spec (forms 55, reader 31).

---------

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

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

@@ -296,13 +296,36 @@
                   (if (seq? c)
                     `(or ~@(map (fn [v] `(= ~g ~(mk-const v))) c))
                     `(= ~g ~(mk-const c))))
+        ;; Collect test constants pairwise (so a trailing unpaired default is
+        ;; excluded), flattening list/or-group tests into individual constants.
+        ;; seed-only fns (reduce/conj/first/rest/drop/empty?/seq?) — analyzer.clj
+        ;; uses case during its own build, before some/distinct load.
+        collect (fn* collect [cls acc]
+                  (if (or (empty? cls) (empty? (rest cls)))
+                    acc
+                    (let [t (first cls)
+                          acc (if (seq? t) (reduce conj acc t) (conj acc t))]
+                      (collect (drop 2 cls) acc))))
+        ;; first duplicate constant, wrapped in [x] (so a duplicate nil is detected);
+        ;; nil = none. Clojure rejects duplicate case constants at compile time.
+        first-dup (fn* fd [items seen]
+                    (if (empty? items)
+                      nil
+                      (let [x (first items)]
+                        (if (reduce (fn [f s] (or f (= s x))) false seen)
+                          [x]
+                          (fd (rest items) (conj seen x))))))
+        dup (first-dup (collect clauses []) [])
         build (fn build [cls]
                 (if (empty? cls)
-                  nil
+                  ;; no clause matched and no default — Clojure throws here.
+                  `(throw (ex-info (str "No matching clause: " ~g) {}))
                   (if (empty? (rest cls))
                     (first cls)
                     `(if ~(mk-test (first cls)) ~(nth cls 1) ~(build (drop 2 cls))))))]
-    `(let* [~g ~expr] ~(build clauses))))
+    (if dup
+      (throw (str "Duplicate case test constant: " (first dup)))
+      `(let* [~g ~expr] ~(build clauses)))))
 
 ;; for: list comprehension, desugared to nested map/mapcat over the binding colls.
 ;; Per binding group: :when wraps the inner form in (if test (list inner) []) so