test: port clojure-test-suite as baseline-guarded integration battery

Run the external cross-dialect clojure-test-suite (lread/clojure-test-suite,
240 per-fn .cljc files in clojure.test format) against Jolt:

- test/support/clojure_test.clj: minimal clojure.test + portability shims
  (deftest/is/testing/are + when-var-exists/thrown?/big-int?/lazy-seq?) — just
  enough surface to load the suite and tally pass/fail/error. Pre-loaded so the
  suite's (require [clojure.test ...]) finds it already populated.
- test/integration/suite-worker.janet: one-shot worker that loads the shim,
  the suite's number-range helper ns, and a single .cljc file, then prints
  'pass fail error'.
- test/integration/clojure-test-suite-test.janet: spawns a worker per file
  under an ev/with-deadline wall-clock budget (so infinite-seq tests that hang
  Jolt's eager evaluator are auto-contained, not a manual skip-list) and asserts
  pass/clean-file counts stay at/above a baseline. References ~/src/clojure-test-suite
  if present; skips cleanly when absent, like the jank battery.

Current: 210 files run, 7 timed out, 2233 assertions -> 1683 pass / 350 fail /
200 error, 23 clean files. Remaining fails are genuine divergences (float/ratio/
bigint, lenient transients where Clojure throws), tracked separately.

Fixes two real evaluator bugs the suite surfaced:
- :refer now preserves a referred macro's :macro flag (was interned as a plain
  value, degrading referred macros to functions).
- resolve-var now resolves ns aliases (like resolve-sym), so aliased macros
  (e.g. p/thrown? via :as p) dispatch as macros instead of being called as fns.

test/integration/suite-worker.janet

@@ -0,0 +1,40 @@
+# One-file worker for the clojure-test-suite battery. Loads the clojure.test
+# shim, evaluates a single suite .cljc file, runs its deftests, and prints
+# "pass fail error" to stdout. Used by the discovery pass to find files that
+# hang under Jolt's eager evaluation (run under an external timeout).
+(use ../../src/jolt/api)
+(use ../../src/jolt/reader)
+(use ../../src/jolt/evaluator)
+
+(defn- parse-forms [src]
+  (var s src) (def fs @[]) (var go true)
+  (while (and go (> (length (string/trim s)) 0))
+    (def r (protect (parse-next s)))
+    (if (not (r 0)) (set go false)
+      (let [p (r 1)] (set s (p 1)) (when (not (nil? (p 0))) (array/push fs (p 0))))))
+  fs)
+
+# A helper, not a standalone test: it needs a .cljc path argument. When `jpm
+# test` runs it with no args, no-op cleanly so it doesn't count as a failure.
+(def path (get (dyn :args) 1))
+
+(when path
+  (def ctx (init))
+  (each f (parse-forms (slurp "test/support/clojure_test.clj")) (eval-form ctx @{} f))
+
+  # Pre-load the suite's own clojure.core-test.number-range helper ns if present
+  # (35 files require it for r/max-int, r/max-double, … — its :default branches are
+  # plain numeric literals Jolt can read). Its `ns` form sets the namespace; the
+  # test file's own `ns` form switches back afterwards.
+  (let [dir (string/slice path 0 (- (length path) (length (last (string/split "/" path)))))
+        nr (string dir "number_range.cljc")]
+    (when (os/stat nr)
+      (each f (parse-forms (slurp nr)) (protect (eval-form ctx @{} f)))))
+
+  (eval-string ctx "(clojure.test/reset-report!)")
+  (each form (parse-forms (slurp path)) (protect (eval-form ctx @{} form)))
+  (protect (eval-string ctx "(clojure.test/run-registered)"))
+  (def p (eval-string ctx "(clojure.test/n-pass)"))
+  (def f (eval-string ctx "(clojure.test/n-fail)"))
+  (def e (eval-string ctx "(clojure.test/n-error)"))
+  (printf "%d %d %d" (if (number? p) p 0) (if (number? f) f 0) (if (number? e) e 0)))