robot.lisp: Beginnings of a simple robot player.

It can usually beat me, so I'm obviously really bad at this.  And I can
think of lots of ways of making it better.

atoms.lisp: Call `player-turn-begin' from the main loop.

This will prevent huge recursion when multiple robots play each other.
Also, make sure that the first player is told at the beginning of the
game.

atoms.lisp: Style cleanup.

atoms.lisp: Multiple player types.

Keep a list of player type names and classes, and allow the user to
fiddle with player types in the `new game' dialogue.

atoms.lisp: Don't start the game automatically.

Also, rename the default players.

atoms.lisp: Move `export' calls to near the appropriate definition.

atoms.lisp: Rewrite `update-undo-redo-sensitivity'.

Less duplication, and no hideous line-breaks.

atoms.lisp: Fix undo/redo action sensitivity.

Undo should be available after the first turn, but wasn't.  The reason
is twofold:

  * `update-undo-redo-sensitivity' was hooked onto :processing-move
    rather than :start-turn, which was just a mistake, though it seemed
    not to be because the order of the notifications was wrong; and

  * `perform-explosions', which is where :start-turn is issued, was
    being called before the undo record was laid down, whereas it should
    always have been afterwards.

atoms.lisp: When restoring an unstable position, continue the animation.

Otherwise, the following thing goes wrong.  You make a move which starts
a chain reaction; you undo it before the reaction has resolved and there
are still atoms from other players; and then you redo the move.  At this
point, you have a static board and nobody can play, since both players
are :playing.

atoms.lisp: Allow a single player.

He can't win, but that's OK.  It still allows some experimentation with
the rules.

atoms.lisp: Reorder the notifications in `play-cell'.

Really :processing-move should always come before :start-turn.

atoms.lisp: Cancel the explosion animation when we restore a snapshot.

Otherwise we get terribly confused about who's supposed to be playing.

atoms.lisp: A player about to make a move is active.

Fixes a bug in `game-update-scores' which you should never actually see,
since a player shouldn't become ready if the game's already been won.
But this was exposed by another bug, so I might as well fix it.

Initial commit.