Chez Phase 1 (increment 3i): regex via vendored irregex

Closes the last clojure.core prelude emit gap (parse-uuid): the whole
non-macro core now lowers to Scheme (prelude reach 355/355).

A #"..." literal analyzes to a :regex IR node. The Chez back end emits
a jolt-regex value over irregex (Alex Shinn, BSD), vendored as the
vendor/irregex submodule -- a portable Scheme regex with PCRE/Java-style
string patterns and first-class Chez support. host/chez/regex.ss wraps
jolt's re-* surface over it: irregex-match -> re-matches (anchored),
irregex-search -> re-find, groups as Clojure [whole g1 ...] vectors,
re-seq as a jolt seq. re-pattern/re-matches/re-find/re-seq/regex? are
def-var!'d into clojure.core so prelude / -e code resolves them.

They stay OUT of the subset native-ops on purpose: irregex's
Unicode/property-class semantics differ from the seed's byte-PEG
approximation, so keeping them prelude-only avoids dragging
engine-difference divergences into the subset-parity corpus. The Janet
back end punts :regex to the interpreter (the seed compiles #"..." to a
Janet PEG), so the main language is unchanged.

Only two adaptations for Chez's top level: a cond-expand shim (Chez's is
library-only) and a normalizing error wrapper (silences irregex's 1-arg
error warnings). rt.ss load is ~0.18s.

emit-test 131/131 (regex literal + re-* parity vs the CLI oracle);
prelude reach 355/355; Chez subset 672/672, 0 divergences; full gate
green.

test/chez/README.md

@@ -72,19 +72,21 @@ catalogs the gaps; macros are skipped (analyze-time only, not a runtime value):
 
     JOLT_CHEZ_PRELUDE=1 janet test/chez/core-prelude-probe.janet
 
-Baseline after inc 3h (host-interop method calls): **354/355 non-macro core forms
-emit** to Scheme (was 348 at inc 3g, 342 at inc 3f). A `.method` call now analyzes
-to a `:host-call` IR node; the Chez emitter lowers it to a `jolt-host-call`
-dispatch for the methods the RT shims — `.write` → port `display`, `.isDirectory`
-→ `file-directory?`, `.listFiles` → `directory-list` — closing the io tier's
-print-method defmethods and `file-seq` (now 20/20). Any other method is out of
-subset (a clean emit-time reject, so it can't masquerade as a compiled-but-broken
-divergence); the Janet back end punts ALL `:host-call` to the interpreter. Prior
-incs: `:quote` reconstructs the raw reader form as RT constructors; `:throw` →
-`jolt-throw`, `:try` → `guard` + `dynamic-wind`, `ex-info` native-op; `letfn` →
-`letrec*`; `declare`/def-no-init → a reserved var cell. Remaining 1 gap: the regex
-literal in `parse-uuid` (needs a regex engine on Chez — see jolt issue). The probe
-has a regression floor (354).
+Baseline after inc 3i (regex): **355/355 non-macro core forms emit** to Scheme —
+the whole non-macro clojure.core now lowers. inc 3i closed the last gap, the regex
+literal in `parse-uuid`: a `#"…"` literal lowers to a `:regex` IR node and the Chez
+emitter emits a `jolt-regex` value over **vendored irregex** (Alex Shinn, BSD,
+`vendor/irregex` submodule) — a portable Scheme regex with PCRE/Java-style string
+patterns. `re-pattern`/`re-matches`/`re-find`/`re-seq`/`regex?` are `def-var!`'d
+into clojure.core (`host/chez/regex.ss`); they stay OUT of the subset native-ops
+(irregex's Unicode/property-class semantics differ from the seed's byte-PEG
+approximation), so they resolve in prelude mode — the path the assembled prelude
+takes — without dragging engine-difference divergences into the subset corpus. The
+Janet back end punts `:regex` to the interpreter (the seed compiles `#"…"` to a
+Janet PEG). Prior incs: inc 3h `.method` → `:host-call` (`jolt-host-call` for
+`.write`/`.isDirectory`/`.listFiles`); `:quote`, `:throw`, `:try`, `ex-info`,
+`letfn` → `letrec*`, `declare`/def-no-init → reserved var cell. The probe has a
+regression floor (355) — every non-macro core form must keep emitting.
 
 Prior, inc 3b (seq tier + dynamic IFn, jolt-5pso): 595/595 compiled, 0 divergences,
 2060/2655 out of subset. The seq tier brought up a list/lazy-seq type with

test/chez/core-prelude-probe.janet

@@ -98,7 +98,7 @@
 
 # Regression floor (raise it as new IR ops / RT shims land, like the suite
 # baseline). Fails if prelude emit reach drops below the recorded baseline.
-(def reach-floor 354)
+(def reach-floor 355)
 (when (< compiled reach-floor)
   (printf "REGRESSION: prelude emit reach %d < floor %d" compiled reach-floor)
   (os/exit 1))

test/chez/emit-test.janet

@@ -300,6 +300,42 @@
   (ok "runtime .isDirectory \"/\" = true" (and (= code 0) (= out "true"))
       (string "chez=" out " | " err)))
 
+# 3m) regex (jolt-i0s3): the #"…" literal lowers to a jolt-regex value over the
+#   vendored irregex; re-pattern/re-matches/re-find/re-seq/regex? are def-var!'d
+#   into clojure.core (not subset native-ops — irregex's Unicode/property
+#   semantics differ from the seed's byte-PEG), so they resolve in PRELUDE mode,
+#   the path the assembled prelude takes. Parity vs the CLI oracle on standard
+#   PCRE patterns both engines agree on.
+(defn run-prelude [src]
+  (emit/set-prelude-mode! true)
+  (def r (protect (emit/emit (backend/analyze-form ctx (in (r/parse-next src) 0)))))
+  (emit/set-prelude-mode! false)
+  (if (not (r 0)) [:emit-err (r 1) ""]
+    (do
+      (spit "/tmp/chez-regex-prelude.ss" (emit/program @[] (r 1)))
+      (def proc (os/spawn ["chez" "--script" "/tmp/chez-regex-prelude.ss"] :p {:out :pipe :err :pipe}))
+      (def out (ev/read (proc :out) 0x100000))
+      (def err (ev/read (proc :err) 0x100000))
+      [(os/proc-wait proc) (string/trim (if out (string out) "")) (string/trim (if err (string err) ""))])))
+
+# bare #"…" literal runs in plain subset mode (the :regex node needs no core fn).
+(each src ["#\"\\d+\"" "(do #\"a.c\")"]
+  (let [[code out err] (d/run-on-chez ctx src) want (cli-oracle src)]
+    (ok (string "regex literal: " src) (and (= code 0) (= out want))
+        (string "chez=" out " janet=" want " | " err))))
+
+# re-* surface via prelude mode (def-var!'d fns), parity vs the CLI oracle.
+(each src ["(re-matches #\"\\d+\" \"123\")"
+           "(re-matches #\"\\d+\" \"12a\")"
+           "(re-find #\"\\d+\" \"abc123def\")"
+           "(re-find #\"([a-z])(\\d)\" \"--a1--\")"
+           "(re-seq #\"\\d+\" \"a1b22c333\")"
+           "(regex? #\"\\d+\")"
+           "(re-matches #\"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\" \"550e8400-e29b-41d4-a716-446655440000\")"]
+  (let [[code out err] (run-prelude src) want (cli-oracle src)]
+    (ok (string "regex: " src) (and (= code 0) (= out want))
+        (string "chez=" out " janet=" want " | " err))))
+
 # 3h) prelude mode (inc 3d): emitting clojure.core ITSELF, a core->core ref must
 #   lower to a runtime var-deref instead of being rejected as "out of subset".
 #   `frequencies` is a core fn but not a native-op, so it exercises the switch.