core.match: regex + array patterns (full support); library-conformance directive

Finishes core.match — its full test suite (115/115) now passes, including the
two patterns the earlier work left out:

- Regex-literal patterns. A #"…" now reads as a regex VALUE (Clojure parity: the
  reader constructs the Pattern, so a macro receives a regex, not jolt's tagged
  form), and the analyzer compiles a regex value to the same :regex IR leaf via
  its source. emit-quoted handles a quoted regex; a regex value carries the
  java.util.regex.Pattern host tag so extend-protocol/instance? dispatch on it.
- Primitive-array patterns. A ^Type hint's :tag is now the SYMBOL (e.g. `ints`),
  matching the JVM, so core.match's array-tag lookup engages the array
  specialization (alength/aget). jolt's :tag consumers already tolerate a symbol
  (hc-cell-num-ret normalizes; tag->nkind/def-meta handle both).

Also: a library-conformance directive in CLAUDE.md, and the supported-libraries
list (docs + site) simplified to one-line entries — a listed library is assumed
to work fully, so no tallies or feature enumerations. core.match + transit-jolt
added to the list.

Seed change (reader/backend/30-macros) -> re-minted; the rest runtime. JVM-
certified corpus rows; the stale `symbol hint -> :tag` divergence is dropped from
the allowlist (jolt now matches the JVM). make test + shakesmoke green.

jolt-core/clojure/core/30-macros.clj

@@ -292,7 +292,7 @@
         ;; exact type up front, so reading it back carries that type (not :any) —
         ;; the key to fast nested-record code. Spliced as a vector literal too.
         field-tags (map (fn [f] (let [mt (meta f)]
-                                  (cond (and mt (:tag mt)) (:tag mt)
+                                  (cond (and mt (:tag mt)) (name (:tag mt))   ; symbol or string -> string
                                         (and mt (:num mt)) "num"
                                         :else nil)))
                         fields)

jolt-core/jolt/backend_scheme.clj

@@ -11,7 +11,8 @@
             [jolt.host :refer [form-sym? form-sym-name form-sym-ns form-sym-meta
                                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-map-pairs form-set-items form-char-code
+                               form-regex? form-regex-source]]))
 
 ;; Hot clojure.core primitives lowered to native Scheme.
 ;; `=` is the exactness-aware jolt= from values.ss; inc/dec/
@@ -289,6 +290,8 @@
     (form-list? form) (str "(jolt-list " (str/join " " (map emit-quoted (form-elements form))) ")")
     (form-vec? form) (str "(jolt-vector " (str/join " " (map emit-quoted (form-vec-items form))) ")")
     (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)) ")")
     ;; 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)) ")")