Message.Valid() now tested for error statuses

We now have two new rules for validity of Messages based on their status

1: NORMAL
    Usual validity rules apply
2: SENDABLE_ERROR
    Message is valid provided the IP and Port fields are not zero
3: NOT_SENDABLE_ERROR
    Always valid

All existing tests are reused and the test messages generated have the
two possible error statuses written to them. We had to split some
message categories so that we knew if a message was expected to have any
missing netwk fields.

Message.IsValid() -> Message.Valid() to be more idiomatic.
Coordinator now validates incoming Messages

If a Message is not valid there are two possible scenarios

1: The Message has network info
    We generate a SENDABLE_ERROR and submit the error Message back into
    the dispatcher

2: The Message has missing network info
    We generate a NOT_SENDABLE_ERROR and submit the error Message back
    into the dispatcher

There is no testing around this. The next step is to perform testing of
the new error handling systems at the unit and network level.
Matcher now matches different stocks separately

Previously the Message.StockId field was ignored by the matcher. Now the
matcher creates a separate pair of match queues for each StockId it has
received.

Tests included in matcher/testsuite.go
Listener/Responder io done via interfaces

Messages being read from and written to the network are using
intermediate interfaces for the purposes. This means we can more easily
swap out network particulars when writing tests.

The most attractive application of this is to be able to more easily
simulate lossy networks in unit tests. We can insert readers and writers
which drop messsages randomly and test the ACK behaviour of the system.

The Listener uses the io.ReadCloser interface which was trivially
swappable with the existing net.UDPConn in the Listener struct. Swapping
a new ReadCloser implementation is done through the constructor.

The Responder uses a custom ipWriter interface which has a local
implementation. This supports a single Write(...) method which takes a
byte slice plus ip:port info. The reason for this is that a UDPConn is
created separately for every response that is written back. This seems
very poor and I strongly expect this approach to be replaced in the
future.
package prioq/ -> matcher/pqueue

Having the priority queue package nested under matcher communicates that
it not expected to be used outside of the matcher package.

The package prioq is still confusing and meaninglesss to me after using
it for quite a while now. pqueue is much easier to understand.