buildsys: change order of gcc flags so we can build with newer versions

https://github.com/grobian/carbon-c-relay/pull/2
relay: drop set but unused variable
README: fixed links in README.md
server_queuereader: don't pollute errno with close()
dispatch_runner: report on accept() errors
server_queuereader: centralise sleep logic

When writing to a server failed, we could end up spin-locking until it
became available again.  This is undesirable (duh), so make the loop
logic detect the error condition and perform the wait to avoid this.
version bump
server: show how much we lose on shutdown (if any)
server_new_qsize: new function to create server

Allow to set the size of the queue.
server_send: don't block if another thread is already blocked on sending
aggregator_numcomputes: function that returns total number of computes
relay: base internal_submission queue size on the aggregator computes

When we have many computations, we might drain the queue quickly, as the
expiry is going and the queue isn't read as quickly as we can generate
the computes.  Therefore allocate enough space to hold a large deal of
this data which is then buffered, instead of dropped.
collector: send stats about the internal submission server
collector_runner: avoid doing the same work many times
build-sys: add dist target
bump version
server: keep connections open if we're writing a lot

Writing data to a closed socket (remote) will succeed.  The next write
will raise an error as the underlying subsystem has detected the
previous write failed.  This means we lose a metric without us noticing.
For that reason we initially reconnected for each batch we did so we
tried reconnecting fairly often and see the failure at that stage.
Downside of that is that we open a lot of sockets, which keep lingering
around a while on servers.  Hence, some hybrid solution, keep the
connection alive as long as we have work.  As soon as we're idle,
disconnect.
server_queuereader: update docs
server_queuerunner: claim a bunch of metrics to write

It feels kind of pointless, but dequeue a whole bunch at a time in a
local "queue" to send it.  Advantage of the local queue is that we don't
have to push back into the queue, and don't have locking overhead, since
we're the only one reading from it.  So overall, this improves
performance at the expense of some memory.
dispatcher: avoid blocking dispatcher threads

Implemented a state in server sending, such that blocking operations
cause the dispatcher to move on, keeping the client waiting.  This
allows the dispatchers to keep on going, doing whatever they /can/ do,
instead of blocking for the clients it serves.