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.

stdlib/clojure/test.clj

@@ -89,13 +89,19 @@
    (cond
      ;; (is (thrown? Class body...))
      (thrown-form? form "thrown?")
-     (let [klass (name (second form))
+     (let [klass-sym (second form)
+           klass (name klass-sym)
            body  (nthrest form 2)]
        `(try
           ~@body
           (clojure.test/fail! (str "expected " '~form " to throw" (when ~msg (str " — " ~msg))))
           (catch Throwable e#
-            (if (clojure.test/class-match? e# ~klass)
+            ;; instance? honors the exception hierarchy (a literal class symbol), so
+            ;; (thrown? IllegalArgumentException …) matches an ArityException subclass
+            ;; like the JVM; class-match? is the simple-name fallback for a class jolt
+            ;; models only by name.
+            (if (or (clojure.core/instance? ~klass-sym e#)
+                    (clojure.test/class-match? e# ~klass))
               (clojure.test/inc-pass!)
               (clojure.test/fail! (str "expected throw of " ~klass " but got " (clojure.core/class e#)))))))
 

stdlib/clojure/walk.clj

@@ -48,6 +48,11 @@
   [smap form]
   (prewalk (fn [x] (if (contains? smap x) (get smap x) x)) form))
 
+(defn macroexpand-all
+  "Recursively performs all possible macroexpansions in form."
+  [form]
+  (prewalk (fn [x] (if (seq? x) (macroexpand x) x)) form))
+
 (defn keywordize-keys
   [m]
   (let [f (fn [[k v]] (if (string? k) [(keyword k) v] [k v]))]