Test.

Let's start with figuring out how to identify the cards. This
test is to make sure that I can identify the Hearts suit.
Refactoring.

I changed the test from 'pretty printing' the card into the much
more useful test of figuring out whether or not two cards belong
to the same suit.

Note! I had to write two tests sice the first one passed.
Implementation.

I did a few different things here. First I modified the function
signature (to make it easier on me) to take two parameters.

The idea in the implementation is to loop through each of the
suits and check whether all of the cards belong to the same one.
Test.

Added two tests with more than two cards.
Implementation.

Ok. This commit contains a little refactoring as well. I broke out
the same-suit implementaion and put in it's own function. At least
for now. That means I had to rename all the tests as well and that's
probably cheating.

The function same-suit-p takes any number of cards and returns t if
they're all in the same suit, otherwise it returns nil. It works by
looping through each of the cards, checking if they all belong to
(member) the same suit using the lists hearts and spades.
Test.

Added some more tests to cover also other suits than Hearts and
Spades.
Implementation.

Added data for the other suits as well. This data should probably
be a defparameter or something instead since it will be shared
with a lot of other functions as well.
Test.

Added a new function called flush-p and some tests for it.

It should return t if all cards are of the same suit.
Implementation.

This implementation is fairly simple since most of the heavy
lifting is done in same-suit-p. I did however have to refactor
the same-suit-p function to work specifically with a list as
input argument instead of the implicit list as provided by the
&rest cards argument. The reason is that it is much easier for
me not to have to worry about splicing the arguments whenever
I need to call an underlying function.
Test.

Added some more tests for flush-p. All of them pass so I'm moving
on to a new function, high-card, to identify the highest card in a
hand.
Implementation.

Moved out the lists of suits to defparameters because I thought
I would need them in the implementation of high-card. However,
having finished that implementation now, it turned out I didn't.
I added another parameter instead called values.

The implementations is based around a sorted list of all cards
and each card has a value that is equal to the length of the list
returned by (member card *values*). The lower the better (at
least for now).