Add a g++-compatible Makefile; fix two major bugs.

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

(Major bug #1) 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.

(Major bug #2) I confused "mulligans" with "hint-stones" in two places
inside SimpleBot. This is now fixed.

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".

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.)
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.
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.88+ ppg, up from 17.84+ ppg.