netwk tests now using client struct

This change simply moves the sending and receiving of UDP messages into
a client struct. The client maintains UDPcoons for communicating with
the matcher. The client is not responsible for any kind of testing and
most methods simply return (*Message, error) or simply error.
Clarified netwk/ package tests by file renaming

It is now clear where the matcher testsuite is being invoked from. It is
equally clear that we have no tests for listen.go
Refactored listen.go for code clarity

Simply chopped up the BIG LOOP into three smaller methods.
Responder now writing to a single ip:port

Previously we attached ip:port info to each message and the responder
would use that to determine where to send the message. This meant that
we needed two classes of errors, errors which could be sent over the
network and errors which could not. Handling this feature proved to be
surprisingly complex.

Now messages have no ip:port info attached and the reponder is
constructed by passing in an io.WriteCloser, to which all messages are
written. This simplifies the error handling, and message validation,
significantly.

There are a number of simple approaches we can take to implement network
communication now.

1: All messages are simply broadcast via UDP - all clients read all
    messages and choose the ones that interest them.
2: A datastructure is created which maps incoming TraderIds to ip:port
    info, the responder uses this to route messages back to individual
    clients
3: The whole system is embedded in another system which communicates via
    channels or some other non-network mechanism. This allows clients
    and matching engine to coexist on one box very easily.

I expect that we will be using UDP broadcast in a production like
environment and using a single 127.0.0.1:<port> UDP connection to act
like a broadcastable network. For super-easy deployment onto VM systems
like Linode we will probably develop a TCP/IP layer wrapping matching
engine and client management into one application.
Message now supports WriteTo/From([]byte)

This pair of methods allow us to serialise/deserialise Messages directly
from a []byte, rather than using the encoding/binary package.

This is useful because it allows us to write undersized datagrams that
come off the network into a Message and then send that message back with
the appropriate error status set.

Additionally we have added specific errors for each kind of error that
can occur. There is a single test for listen.go.
Adding tests for listen.go

Specifically testing the following behaviours

1: A READ_ERROR is produced when there is a error reading (obviously)
2: A SMALL_READ_ERROR is produced when too few bytes are sent
3: Duplicate messages are not resent (altough they are acked)