Add a g++-compatible Makefile.

The sneaky -DBOTNAME= thing has now wormed its way into a real
Makefile.

Also, while Clang apparently allows you to increment enums, that's
not strictly Standard-conforming. I've added the appropriate
overloads as inline operators in "Hanabi.h".
Pass std::vector<int> card_indices by const reference.

No change in behavior.
Send pleaseObserveBefore{Play,Discard} messages to the active player too.

The new method server.activeCard() allows even the currently active
player to see the identity of the card he's playing or discarding.
This makes it meaningful to give the pleaseObserveBeforePlay()
notification to the active bot as well as the others, and allows
the bot writer to consolidate some similar code into that notification
method. Notice how SimpleBot got even simpler after this change.
Add some convenience routines; improve logging.

Instances of Hanabi::Card can now be compared for equality.

When logging is turned on (via Hanabi::Server::setLog()), we'll
log the players' hands every time around the table. This makes
it easier to debug bots.
Fix a huge bug with hint stones; add cardsRemainingInDeck().

The server's pleaseGiveColorHint() and pleaseGiveValueHint()
routines weren't actually using up hint stones! This effectively
gave the bots an infinite number of hints, if they cared to use
them. SimpleBot's average score drops by a whole point after
this change, indicating that indeed SimpleBot was taking
advantage of the server's bug.

The method Server::cardsRemainingInDeck() could be used to change
tactics near the end of the game. For example, when there are
fewer cards left than mulligans, it really doesn't make sense
to ever discard a card. Just try playing it and see what happens.
(SimpleBot will never implement this tactic, but I'm sure I'll
put it in another bot soon.)
Fix a typo-bug in SimpleBot.

I confused "mulligans" with "hint-stones".
Unfortunately, SimpleBot discards enough cards that
it was never in danger of running out of hint-stones,
so this bug had to be found by manual inspection.
Refactor SimpleBot.

This patch pulls each distinct "tactic" out into its own method.
No change in behavior.
Make SimpleBot a little smarter about deduction.

Because SimpleBot gives hints only about playable cards,
you can actually infer the value of a card from a color hint.
For example, if SimpleBot says "this card is red", and there
is currently a 2 on top of the red pile, you know that the
named card must be the red 3.

This extra deduction power also requires that we use the
right logic inside wipeOutPlayables(), so that Alice's
play of the orange 3 doesn't wipe out Bob's knowledge that
his red 3 is playable (despite their both being 3s).

After these two complementary patches, SimpleBot's win
percentage is basically unchanged.
SimpleBot now prefers to play its lowest-value playable card.

The old behavior was that SimpleBot would play its oldest playable
card. This could theoretically result in a sort of "convoying",
where another player's higher card could not be played (=identified
as playable) until SimpleBot got off its lowest card.

After this change, SimpleBot scores 17.89+ ppg, up from 17.84+ ppg.