Make _Predictor directly predict.

When walking the tree, as we know the prediction function, combine each new
step with the existing predictor to produce a single predictor for the whole
conversion, rather than maintaining a list of predictors that need to be
applied in turn.

This finds a spanning forest that covers all receivers that have
sync, and crunches the timestamp predictors that make up the edges
so that there is a single predictor per receiver that knows how to
convert timestamps from that receiver to a shared timescale per
spanning tree.

We can then use that mapping to do clock normalization much faster.

The map has to be recomputed often as it will get stale fast, but even
if we recompute once a second, it works out much cheaper than doing
spanning-tree work on every mlat resolve.

It also has some interesting side benefits due to having a more
global view beyond the receivers that directly receiver a particular
mlat result:

 * We can use a spanning path for conversion of a mlat result that
   includes receivers that did not see the mlat result.
 * If a receiver is synchronized with a Radarcape, it is also
   effectively synchronized with all receivers synchronized with
   _any_ Radarcape.

The spanning tree in the UK testbed often ends up spanning Ireland through
Germany, with all those receivers tied into a single clockbase and able
to contribute useful timings to any mlat-able message they see.

Also, the resulting map is compact (something like 4 values per receiver)
and does not require any additional information to be able to do
clock conversion. So it will make life easier when we start to
want to split up mlat solving between processes: rather than having each
subprocess have to do clock sync, we can do it once and push the results
out to all subprocesses.