Fix general gaps the hiccup suite shook out

Six correctness fixes, each a general gap (not hiccup-specific):

- deftype is not a map. jolt treated every deftype instance as a map
  (map?/record?/seqable over its fields); in Clojure only a defrecord is
  map-like, a bare deftype is an opaque object. defrecord now marks its type;
  map?/record?/coll?/seq/empty? gate on it, while a deftype implementing a
  collection interface still dispatches through its methods.

- cross-ns extend-protocol on an imported deftype. register-method built the
  type tag from the *calling* ns + bare name, so (extend-protocol P Raw …) in
  one ns missed a Raw value defined in another. A simple-name index resolves
  the bare name to the type's real tag (local ns still wins).

- str vs print. str of a collection is its readable form (nested strings
  quoted: (str ["x"]) => ["x"]); print leaves them raw. jolt defined print
  as str, conflating the two. Split via a __print1 seam.

- clojure.test thrown? now honors the exception hierarchy (instance?), so
  (thrown? IllegalArgumentException …) matches an ArityException subclass.

- java.net.URI is value-equal (= and hash by string form).

- clojure.walk/macroexpand-all was missing; an unresolved qualified var made
  the analyzer report "Unknown class walk".

deftype/defrecord + print are seed sources, re-minted. hiccup 365->381 of its
own suite; the rest are charset-encoding / var-meta niches.

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

@@ -59,11 +59,13 @@
 ;; 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.
+;; print renders non-readably (__print1): a nested string is raw, unlike str/pr
+;; which quote it. (print ["x"]) => [x], (str ["x"]) => ["x"].
 (defn print [& xs]
   (__write (loop [out "" s (seq xs) first? true]
              (if s
                (let [x (first s)
-                     r (if (nil? x) "nil" (str x))]
+                     r (__print1 x)]
                  (recur (str out (if first? "" " ") r) (next s) false))
                out)))
   nil)

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

@@ -613,6 +613,8 @@
        ;; deftype already defines ->name (= the ctor); no (name. …) interop needed,
        ;; so defrecord compiles too. map->name builds via that ctor.
        (deftype ~name-sym ~fields)
+       ;; mark the type a record (map?/record?/field-seq); a bare deftype is not.
+       (register-record-type! (quote ~name-sym))
        ;; build via the positional ctor for declared fields, then carry any
        ;; remaining keys as extension fields (JVM keeps them on the record).
        (def ~mapf (fn* [~m]