Numbers-style category dispatch for binary numeric ops

Arithmetic and comparisons lowered to raw Chez ops, so an operand outside
Chez's tower (BigDecimal) crashed with a raw condition, and Chez contagion
leaked: (* 1.0 0) gave exact 0 where the JVM gives 0.0, (* ##Inf 0) gave 0
instead of ##NaN, (/ 1 0) raised an untyped error.

One seam now (host/chez/seq.ss): call position emits jolt-n* macros with the
both-Chez-numbers fast path open-coded; value position folds through the same
binary ops. Anything outside the tower falls to per-op slow hooks that
java/bigdec.ss extends, so bigdec arithmetic works in every position (the old
static-only :bigdec typing limitation is gone). JVM rules patched into the
fast path: a double operand wins, an exact zero divisor throws
ArithmeticException while a double zero divisor yields Inf/NaN, quot/rem/mod
cover ratios and doubles, min/max return the original operand with NaN
winning, a nil operand is NPE and a non-number CCE, zero-arg -// throw
ArityException at runtime instead of failing expansion.

Also: with-precision now binds *math-context* and bigdec results round with
real RoundingMode semantics (UNNECESSARY throws; division rounds to precision
instead of throwing); rationalize goes through the shortest decimal print
like BigDecimal.valueOf (the identity stub is gone); ratios coerce to bigdec
like Numbers.toBigDecimal; min/max int-literal operands no longer coerce to
flonum in the numeric pass.

Perf neutral: fib and seq benches unchanged (the fast path is two type checks
the optimizer folds); hinted fl/fx paths untouched. 19 JVM-certified corpus
rows; cts baseline 5614->5730 pass, 192->88 errors, 84->79 baselined
namespaces.

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

@@ -109,11 +109,15 @@
          (with-open ~(vec (drop 2 bindings)) ~@body)
          (finally (__close ~(first bindings)))))))
 
-;; jolt numbers are doubles — there is no BigDecimal math context, so the
-;; precision (and optional :rounding mode) is accepted and ignored.
+;; Binds *math-context*; BigDecimal arithmetic in the dynamic scope rounds its
+;; results to the precision with the rounding mode (default HALF_UP, like
+;; java.math.MathContext).
 (defmacro with-precision [precision & exprs]
-  (let [body (if (= :rounding (first exprs)) (drop 2 exprs) exprs)]
-    `(do ~@body)))
+  (let [[rounding body] (if (= :rounding (first exprs))
+                          [(second exprs) (drop 2 exprs)]
+                          ['HALF_UP exprs])]
+    `(binding [clojure.core/*math-context* {:precision ~precision :rounding '~rounding}]
+       ~@body)))
 
 (defmacro with-bindings [binding-map & body]
   `(with-bindings* ~binding-map (fn [] ~@body)))