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.

src/jolt/evaluator.janet

@@ -149,7 +149,12 @@
   [ctx bindings sym-s]
   (let [name (sym-s :name) ns (sym-s :ns)]
     (if (not (nil? ns))
-      (let [target-ns (ctx-find-ns ctx ns)] (ns-find target-ns name))
+      # Resolve ns aliases (e.g. `p/thrown?` where `p` is a require :as alias)
+      # so that aliased macros are recognized as macros, matching resolve-sym.
+      (let [current-ns (ctx-find-ns ctx (ctx-current-ns ctx))
+            aliased-ns (ns-import-lookup current-ns ns)
+            target-ns (ctx-find-ns ctx (or aliased-ns ns))]
+        (ns-find target-ns name))
       (if (get bindings name) nil
         (let [current-ns (ctx-current-ns ctx)
               ns (ctx-find-ns ctx current-ns)
@@ -222,7 +227,11 @@
         (each refer-sym refer-syms
           (let [name (if (struct? refer-sym) (refer-sym :name) refer-sym)
                 v (ns-find source-ns name)]
-            (when v (ns-intern target-ns name (var-get v)))))))
+            (when v
+              # Preserve macro-ness: a referred macro must stay a macro, so copy
+              # the :macro flag onto the interned var (not just its value).
+              (let [nv (ns-intern target-ns name (var-get v))]
+                (when (get v :macro) (put nv :macro true))))))))
     nil))
 
 (defn- bind-put