General fixes shaken out by clojure/tools.reader

Running clojure.tools.reader's own suite on jolt surfaced a batch of general
gaps (all runtime, JVM-certified, no re-mint — reader.ss is loaded at runtime
and jolt-core has no octal literals, so selfhost holds):

Reader:
- (load "rel") resolves a non-/ path against the current namespace's directory,
  like Clojure — (load "common_tests") from clojure.tools.reader-test loads
  clojure/tools/common_tests.clj. Was resolved against the roots directly.
- Octal integer literals: 042 reads as 34, not decimal 42; octal string escapes
  (\377 is one char, not \0 + "00"). \oNNN char octal already worked.
- (symbol nil name) now equals (symbol name) and the reader literal — a nil
  namespace is the #f no-ns sentinel, not jolt-nil (jolt= compares ns by equal?).

clojure.test:
- thrown-with-msg? honors the class hierarchy (instance?) before falling back to
  a simple-name match, so (thrown-with-msg? RuntimeException ...) matches an
  ExceptionInfo, like thrown? already did.

Host interop (java layer):
- java.util.regex: Pattern.matcher / Matcher.matches / .group / .groupCount /
  .find, and Pattern/compile.
- clojure.lang: RT/map, PersistentList/create, PersistentHashSet/createWithCheck.
- java.lang.Character: digit / isDigit / isWhitespace / valueOf.
- java.util.LinkedList (Deque surface over the ArrayList backing); ArrayList /
  LinkedList are now seqable.
- BigInteger 2-arg ctor (string, radix) + .negate / .bitLength / .signum / .abs;
  BigInt/fromBigInteger and Numbers/reduceBigInt (identity on jolt's exact ints).

Suite: reader_test 22/30, reader-edn_test 13/16. The remaining failures are
fundamental numeric-model differences (no BigDecimal type; BigInt and Long are
one exact-integer type) or need JVM reflection (record/ctor tagged literals via
getConstructors) — out of scope.

make test green (+8 corpus rows, 0 new divergences), shakesmoke byte-identical.

host/chez/regex.ss

@@ -221,6 +221,21 @@
     (if last (irx-result last)
         (jolt-throw (jolt-ex-info "No match found" (jolt-hash-map))))))
 
+;; java.util.regex.Matcher methods over a matcher-t. .matches anchors a full-region
+;; match and remembers it for .group; .group n returns submatch n (0 = whole) or
+;; nil; .groupCount is the pattern's capturing-group count.
+(define (jolt-matcher-matches m)
+  (let ((mm (irregex-match (matcher-t-irx m) (matcher-t-str m))))
+    (matcher-t-last-set! m mm)
+    (if mm #t #f)))
+(define (jolt-matcher-group m . n)
+  (let ((last (matcher-t-last m)))
+    (if last
+        (let ((s (irregex-match-substring last (if (pair? n) (->idx (car n)) 0))))
+          (if s s jolt-nil))
+        (jolt-throw (jolt-ex-info "No match available" (jolt-hash-map))))))
+(define (jolt-matcher-group-count m) (irregex-num-submatches (matcher-t-irx m)))
+
 ;; All non-overlapping matches, left to right. Advance past each match end (or by
 ;; one on a zero-width match). nil when there are no matches (Clojure: seq-able as
 ;; nil, so (if-let [m (re-seq ...)] ...) works).