Major restructuring of how streams work. Neither input nor output
streams are now blocking. This avoids stalling the rest of the client or
server when a peer is slow or unresponsive.

Note that this puts an extra burden on users of streams to make sure
they are allowed to do their work once the underlying transports are
ready (e.g. monitoring fds).

Just have a simply number of bytes argument to avoid a lot of
complexity.

Makes it more readable to write code that needs to know how much
data/space is available in a stream.

The CConnection base class wants to be able to write things these days,
so we need to provide it a place to do so.

They have very different purpose, so make things easier to work
with by having multiple directories.

We now filter incoming data, which means we can start assuming the
clipboard data is always null terminated. This allows us to clean
up a lot of the internal handling.

Avoid using the callbacks used for runtime changes for the initial
setup. They weren't really useful anyway as you could not allocate
a framebuffer without also knowing the pixel format. So make things
more clear by letting serverInit() get the initial settings.

We need to track different things in the server and client, so
separate things to two independent structures to keep things more
clear.

Avoid direct access to the screen dimensions and layout so that we
can make sure it stays sane. This also makes sure the layout is
properly updated when we only get the screen dimensions from the
server.

We use polymorphic exception objects, so catching by value invokes
the copy constructor and stuff that we don't really want.

This will allow us to use better formats that preserve the entire
alpha channel.

This is based on comparing CPU time with elapsed time, which means
that the tests can be heavily influenced by other load on the test
machine.

We need more callbacks for correct operation of multi-threaded
rect decoding.

Done in preparation for multi-core decoding. Keeps the complexity
out of the other classes. This also moves ownership of the
framebuffer in to CConnection. It's the CConnection object that is
aware of the threads and how to synchronise with them. Therefore
the ownership of the framebuffer must also be there to make sure
it isn't deleted whilst threads are working.

This prevents unhandled exceptions if the file isn't found.