It's currently very hard to unit test the methods of the Router type
because it's so tightly coupled with program initialisation stuff in the
main module.

Moving it into its own module is the first step towards fixing this.

It's much easier to read and debug as a standalone shell script, plus we
get shellcheck coverage.

Hopefully this fixes the last of the mongo startup flakiness.

Move version.go from main to the router module (lib/) so that it can
(later) be accessed from Router itself.

Make it use standard debug.BuildInfo that the Go toolchain produced
automatically, so we no longer have to mess about with shell scripts
and linker flags.

This eliminates some unnecessary differences between the Dockerfile and
Makefile builds.

It's useful to see the version string in the logs on startup.

Registering metrics in a global namespace is neither test-friendly nor
concurrency-safe. There's also the potential for name clashes to cause
panics on startup, which can even happen implicitly on import because
we've been calling prometheus.MustRegister() from module init functions.

Injecting a prometheus.Registerer will allow us to write proper
integration tests (and be able to run them in parallel), rather than
almost everything having to be an end-to-end test that forks and execs
an external Router binary.

Also don't export Prometheus objects from modules. Nothing outside the
module should depend on implementation details of the module's metrics.
The public interface for reading metrics within the same process is
prometheus.Gatherer. For everything else, there's `/metrics`.

<insert mean joke about Java>

NewRouter()'s parameter list was already getting out of hand.

Copying it straight into struct Router for now just for the sake of
convenience. Probably change that soon.

Only the main module now touches the default Prometheus registry.

We want to be able to refactor some of our unnecessarily-end-to-end
tests into integration tests (in the true sense) and unit tests. To do
that, we can't have components messing with global state.

This also improves separation of concerns generally. For example, the
triemux and handlers modules can no longer cause panics simply by being
imported if there's a metric name clash.

It's way simpler to use cmd.Env.

This eliminates the annoying "wants to accept incoming connections"
popups on macOS.

Unnecessary abstraction in test helpers can easily undermine the value
of the tests. Get rid of unnecessary logic and just be explicit.

Most of this was generated with some sed-foo.

In a test that's supposed to check whether reloading the route table
works, asserting that the async reload request took < 5 ms is neither
helpful nor tasty, unlike this other [recipe for
flakes](https://bakewithsarah.com/chocolate-fudge-flake-cake/).

Also don't request the reload twice; it's unnecessary and makes the test
slightly less useful, e.g. it would fail to catch a bug where the reload
fails the first time but succeeds on retry.

The default poll interval is 2 s, so wait 3.

This doesn't slow down the test; gomega.Eventually polls every 10 ms by
default.

`/stats` is disused and useless now that we have a Prometheus gauge for
the route count. It didn't use to return anything else.