*unchecked-math* on macro-emitted arithmetic + local shadowing a bare native op

Two general fixes shaken out by clojure.test.check's own suite (its splittable
PRNG mixes 64-bit longs and binds locals named min/max).

- *unchecked-math* now wraps arithmetic a macro emits. The analyzer rewrote a
  bare (+/-/*) to its wrapping unchecked-* under *unchecked-math*, but a macro's
  syntax-quote produces clojure.core/* (qualified), which was skipped — so e.g.
  test.check's mix-64 multiply grew to a bignum instead of a 64-bit long. The
  rewrite now also fires on the clojure.core-qualified form.
- A local binding named like a bare-emitted native op no longer shadows it. ops
  where native-ops maps the name to itself (+ - * / < > min max …) emit as the
  bare Scheme name; a local `max` emitted the same token, so
  (fn [max] (clojure.core/max …)) called the param. munge-name now prefixes such
  locals, like reserved words (derived from native-ops so they can't drift).

make test green (+1 corpus row, 0 new divergences), shakesmoke byte-identical.
One re-mint (analyzer + backend).

jolt-core/jolt/analyzer.clj

@@ -636,9 +636,14 @@
                           (form-sym-name head)))
             shadowed (and hname (local? env hname))
             ;; under *unchecked-math*, a core +/-/*/inc/dec becomes its wrapping
-            ;; unchecked-* (computed once; nil when off or not such an op).
-            unm (when (and hname (not shadowed) (unchecked-math?))
-                  (unchecked-arith hname (count items)))]
+            ;; unchecked-* (computed once; nil when off or not such an op). The op
+            ;; may arrive bare (+) or clojure.core-qualified (clojure.core/*), the
+            ;; latter from a macro's syntax-quote — both must wrap.
+            unm (when (unchecked-math?)
+                  (let [opn (cond (and hname (not shadowed)) hname
+                                  (and (form-sym? head) (= "clojure.core" (form-sym-ns head)))
+                                  (form-sym-name head))]
+                    (when opn (unchecked-arith opn (count items)))))]
         (cond
           ;; *unchecked-math* rewrite, before macro/special dispatch (these are
           ;; ordinary core fns). The unchecked-* form re-analyzes normally.