Network Stack (Linux, Windows rework)

Refactored the new Windows network stack to fix some poor design
decisions (the Connection object was too tightly-coupled with the
ConnectionHandler object, they both performed functions for each other,
when in realily only the ConnectionHandler performing tasks for the
Connection made sense/was necessary).

Fixed some could've-been-bugs, mostly in the area of
exception-/error-handling.

Reworked the way the asynchronous lambdas are invoked to avoid a few
SmartPointer copies (the SmartPointers are now moved instead).

Reworked the way the receive loop works so that the entire stream is
guaranteed to be read (before it was possible that the client would send
bytes, disconnect, a write would be attempted, fail, the connection
would be disconnected, and those bytes would never be read).

The way it used to work was as follows:

1. Some socket operation would encounter an error.
2. This error would trigger a disconnect, which whould shut down the
socket for reads and writes.
3. The receive loop (three asynchronous events which formed a loop)
would stop at once (perhaps leaving bytes unread/processed).
4. Once all pending sends had failed, and the receive loop was stopped,
the socket would be removed from the handler and closed.

Now it works as follows:

1. Some socket operation encounters an error.
2. This error triggers a disconnect, which shuts down the socket for
reads and writes.
3. The receive loop (the same three asynchronous events) will not stop
until there is an error receiving or an asynchronous receive returns 0
bytes (i.e. end of stream).  This end of stream is guaranteed to occur
quickly due to the fact the socket was shut down.
4. Once all pending sends have failed, and the receive loop has finished
reading the stream, the socket is removed from the handler and closed.

Fixed a bug where WSACleanup wouldn't be called when the
ConnectionHandler was destroyed.

The rework of the network stack also meant that most posting to the I/O
completion port is no longer necessary (posts used to be performed on
every disconnect and connect, now they're only necessary on every
connect (to get the receive loop started)), which should very, very
slightly (probably unnoticeably) improve performance.  Regardless of the
performance increase (or lack thereof) it's a much better design now.

Started work on a Linux Makefile.

Split the network stack into two parts -- Linux and Windows -- and wrote
a Linux implementation (it compiles, but is otherwise totally untested)
which uses epoll rather than I/O Completion Ports (since Linux doesn't
have IOCP).

Removed a few files that were leftovers from my first attempted redesign
of the network stack (which went nowhere and I quickly abandoned in
favour of complete rewrites).