Others divide up this space differently than I, but for most purposes,
I personally regard them as distinct langauges, not mere dialectal
variations, although plainly they are from what I would call the same
language family.

You will probably prefer to use one or the other in the end, but they
each have things to teach you.  Even if you prefer to use neither, you
will use the things you learn from these languages in your future
thinking, becuase they will give you metaphors for thinking about
things that other languages do not.

Both are fine languages.  The choice seems to mostly be made by the
personal preferences of the programmer.  Different personalities are
attracted to features of one or another.  

Scheme is more of a single-paradigm language, appealing to people who
like to be told there's a single small core of stuff that they need to
learn and then they can compose what they need from that.  Its design
has a strong focus on aesthetic and formalism.  For many years, its
specification eschewed including detail information such as error
handling behavior, portability concerns, branch cuts, etc. because it
complicated an otherwise tidily small specification, although of late
this has finally begun to change.  Overall, though, it's a sort of
Republican, nearly Libertarian, approach to language design that
assumes languages shouldn't do for people what they can do for
themselves.  Scheme has tended to prefer a small language core with
additional functionality added as libraries.  As an example, the
Scheme does not have a primitively defined object system, although
there are object systems you can load.

CL is a larger language that offers more out of the box, including
multiple programming paradigms, and a great deal of baggage the
purpose of which is to allow people who program in multiple paradigms
to interact gracefully with one another. CL's aesthetics were
subordinate in design to pragmatic decisions of various kinds.  It has
a rich tradition of compromise in its design in order to accommodate a
varied community.  It's a sort of Democrat / Great Society approach to
language design that assumes people are more concerned with getting
things done than with fussing over religious notions of finding the
single right way to do things, and in some ways makes a kind of art
form out the what some might see as the messy aspects of
multiculturalism, even to the point of providing specific language
features whose sole goal is to allow disagreeing communities to share
the same space without being at each others' throats.  Common Lisp has
a heavily articulated object system (CLOS) and an elaborate
error-handling system, both of which are strongly integrated into the
standard language.

It's EXTREMELY hard to make any comparison without risking being
accidentally critical of one or the other community.  I have tried to
present both of these paragraphs in ways that show both perceived
positives and perceived negatives of both communities, not in order to
start a firestorm, but to give you a sense that each community has
things they are proud of and things that annoy the other.  Looking at
the above paragraphs, I'd hope that most people will find that they see
a bit of truth in them and moreover that the users of the languages
understand that, even if I didn't correctly capture it, there really
is something of the general kind I'm describing at work in how the two
communities differentiate.

There are other ways to make the decisions, btw.  Availability of good
texts is an example.  There are good books available for both languages,
but on unrelated topics, so it's a bit apples and oranges there.  I'm
sure others have opinions on that, so I'll stop here and will assume
others will take up the slack.