Basic Chat, Bugfixes

Added a "Basic Chat" module which implements broadcast chat
functionality.  Clients can send chat messages and those chat messages
will be broadcast to everyone connected to the server.

Designing this led to me making several changes to the parent chat
module.  I added a typedef for its callback type, and changed some of
its method types from const reference to by value, which allows these
functions to be much more efficient faced with calling functions who are
finished with their string thereafter (which will probably be most of
them).

Added a new, type safe Retrieve function to Packet, which also has the
advantage of scraping its return types directly from PacketTypeMap
specializations, which means that it leads to more maintainable code (if
a type changes, change it in one place, it automatically changes
everywhere else).

Hunted down a nasty bug in the receive side of the server which led to
the decryption buffer ever-growing, with the events being dispatched to
handle packets slowly falling further and further behind.

This was caused by the way encryption is implemented with respect to the
receive handler.  The receive handler checked its own buffer for excess
bytes and if there were some (after parsing a packet) it looped and
tried to parse another packet.  But the decryption API of the client
consumes all bytes, decrypting them and placing them in its own internal
buffer.  Therefore after parsing one packet the receive handler would
think that it was out of bytes, when in reality many bytes were waiting
in the Client object's internal decryption buffer.

The solution was to have the receive handler simply call the Receive
function of the client until it returns false, rather than checking its
own buffer.

Also added a function -- Count -- to Client which allows the receive
handler to check the size of the decryption buffer.  This allows the
maximum buffer size restriction to be enforced both on the decryption
buffer and on the buffer the receive handler is passed (which is owned
by the network stack).

This ensures that authenticated/encrypted clients cannot denial of
service the server by sending it infinite amounts of garbage, unless the
server administrator sets the buffer size restriction to infinity, in
which case its his problem, not mine.

Rewrote the main receive part of the receive thread (in the network
stack).  Now rather than receiving data, dispatching a handler, and then
moving onto the next socket/select again it loops receiving data as long
as a non-blocking poll of the socket-in-question specifies that it's
readable.  This does two things:

1. It reduces the amount of time the receive thread wastes spinning.  If
a receive fails to retrieve all data from the underlying receive buffer
the receive thread will tightly loop, resize the buffer, and retrieve
more data.  Before it would have to go through the entire process of
rebuilding its select socket set, calling select, scanning the socket
list and matching up with sockets in the socket set, et cetera.

2. It reduces the number of spurious times the receive handler is
called.  Previously if the receive thread received part of a packet, and
the remainder was in the underlying receive buffer, it would dispatch
the receive handler with a partial packet, which would waste time
parsing out the packet, only to discover it was incomplete.  Granted
packets are built incrementally, so this isn't as much of an issue, but
in between build increments there's still the wasted parsing overhead.
Now the handler is not dispatched until the socket specifies that it is
no longer readable.  This means that the number of times the receive
handler is dispatched with a partial packet should be reduced greatly,
especially for larger packets.

Fixed a bug in the packet router.  The size of the routing array was set
to std::numeric_limits<Byte>::max(), but that's the maximum index that I
wanted, not the count, the count is std::numeric_limits<Byte>::max()+1,
which is now reflected in the declaration (and the corresponding
initialization loop).

Fixed typos in a few comments.

Added a test program, for use in testing things that don't need the test
front-end to be tested (or when I want to isolate components for
testing).

Added a module to handle 0xFF Disconnect/Kick.  This isn't strictly
necessary (the network stack detects connection breaks and kills the
connection appropriately, and the keep alive/timeout module kills
inactive clients), but it's nice to have the logging and the prompt
closure of connections, and it took less than 15 minutes to write.

Updated the makefile to accomodate new modules/executables, and so that
new_delete.cpp/new_delete.o is built into everything.  This allows me to
use a new feature of RLeahyLib to track memory allocations/deallocations
and hunt for memory leaks (I haven't found any thus far).