Fix 4 clojure.core bugs surfaced by JVM certification

The corpus certifier (test/conformance) flagged four cases where jolt's
hand-written :expected matched a real defect rather than Clojure. Fixed in the
jolt-core overlay, corrected the spec :expected, re-certified against JVM Clojure:

- ex-message: returns nil for a non-throwable (dropped the lenient string branch);
  still returns the message for ex-info. (jolt-l8e8)
- munge: preserves the argument's type — a symbol munges to a symbol, not a string.
  (jolt-hc35)
- print: (print nil) emits "nil", not "" (top-level nil guard; str yields "").
  (jolt-pqio)
- bounded-count: uses the counted? fast path (full count), else counts up to n via
  seq — was (min n (count coll)), wrong for counted colls. Added an uncounted-coll
  spec case. (jolt-2507)

Removed the 4 :bug entries from known-divergences.edn (now certified), regenerated
corpus + profile, re-minted the Chez bootstrap seed (clojure.core changed). Gates:
Janet 155/0, JVM certify clean, both Chez corpus gates 2534 (floors raised),
bootstrap 6/6, fixpoint intact.

jolt-core/clojure/core/20-coll.clj

@@ -55,10 +55,16 @@
 
 (defn prn [& xs] (apply pr xs) (__write "\n") nil)
 
+;; print renders each arg non-readably (strings/chars unquoted) like str — except
+;; nil, which prints as "nil" (str yields ""). Only the top-level arg needs the
+;; guard; nil nested in a collection already renders as "nil" via the collection
+;; printer.
 (defn print [& xs]
   (__write (loop [out "" s (seq xs) first? true]
              (if s
-               (recur (str out (if first? "" " ") (str (first s))) (next s) false)
+               (let [x (first s)
+                     r (if (nil? x) "nil" (str x))]
+                 (recur (str out (if first? "" " ") r) (next s) false))
                out)))
   nil)
 
@@ -210,7 +216,11 @@
       (recur (dec n) (next xs))
       xs)))
 
-(defn bounded-count [n coll] (min n (count coll)))
+(defn bounded-count [n coll]
+  (if (counted? coll)
+    (count coll)
+    (loop [i 0 s (seq coll)]
+      (if (and s (< i n)) (recur (inc i) (next s)) i))))
 
 (defn run! [proc coll] (reduce (fn [_ x] (proc x) nil) nil coll) nil)
 
@@ -650,7 +660,6 @@
 (defn ex-message [e]
   (let [e (ex-unwrap e)]
     (cond (ex-info-val? e) (get e :message)
-          (string? e)      e
           :else            nil)))
 (defn ex-cause [e]
   (let [e (ex-unwrap e)] (if (ex-info-val? e) (get e :cause) nil)))
@@ -785,8 +794,12 @@
 ;; No class hierarchy on the Janet host.
 (defn supers [x] #{})
 
-;; The kernel's munge only rewrote dashes; kept as-is for parity.
-(defn munge [s] (str-replace-all "-" "_" (str s)))
+;; Like Clojure's munge: rewrite dashes to underscores, preserving the argument's
+;; type — a symbol munges to a symbol, anything else to a string. (jolt only
+;; rewrites dashes, not the full Compiler CHAR_MAP.)
+(defn munge [s]
+  (let [m (str-replace-all "-" "_" (str s))]
+    (if (symbol? s) (symbol m) m)))
 
 (defn test
   "Calls the :test fn from v's metadata; :ok if it runs, :no-test if absent."