To make a statement about Common Lisp from simple tutorial code is a bit much.

If one looks at music software in Common Lisp, the code is on a higher level than building lists like that.

> Secondly, this code tries to handle lists in the classic Lisp way, with recursion, and that's not what you typically do in Clojure.

Neither is it done in Common Lisp.

> Those 7 lines of Common Lisp compress to 2 lines of Clojure

The actual difference is that Common Lisp uses LOOP and not FOR, and that LOOP needs two nested LOOP forms:

    CL-USER 11 > (defun build (list1 list2)
                  (loop for e1 in list1 append
                        (loop for e2 in list2 collect (list e1 e2))))
    BUILD

    CL-USER 12 > (build '(1 2) '(a b))
    ((1 A) (1 B) (2 A) (2 B))

Two iteration forms in a LOOP don't nest, but provide iteration bindings similar to LET* and LET:

    (loop for i in '(1 2 3) for j = (expt i 2) collect (list i j))

and

    (loop for i in '(1 2 3) and j in '(1 4 9) collect (list i j))

Common Lisp's ITERATE macro also needs nested forms, but slightly improved over LOOP:

    ITER-USER 26 > (iterate outer (for i in '(1 2))
                     (iterate (for j in '(a b))
                       (in outer (collect (list i j)))))
    ((1 A) (1 B) (2 A) (2 B))

The author of Clojure knows these differences very well, since he was a heavy Common Lisp user for a few years.

> But, at the same time, if you're looking to translate stuff from other Lisps into Clojure, it's not going to be just copying and pasting. Beyond inconsequential, dialect-level differences like defn vs. defun, there are deeper differences which steepen the learning curve a little.

That's true. Clojure is not a Lisp, but partially derived from it, with many other influences from Haskell and other languages. It's mostly incompatible to Lisp: software can't be shared or copied, it needs to be complete rewritten. Thus basic Lisp literature is only of use when it's about features which got copied. For example the book 'On Lisp' might help to understand macros in Lisp and Clojure, whereas books like 'Practical Common Lisp' or Norvig's PAIP aren't very useful for Clojure programmers.