No functional changes in this commit.

No functional change.

Each split corresponds to a potential move instruction, so try as hard
as possible to ensure these don't end up inside loops.

The core logic is in the `adjust_split_point_forward` and
`adjust_split_point_backward` functions which select a split point
between two `ProgPoint`s which has the lowest possible loop depth.

This is applied both when initially selecting a split point and when
the edges of the split point are trimmed into the spill bundle.

The core functionality for splitting a bundle is now in the
`split_bundle_at` function, which is called from various places.

The only functional change in this commit is that the special handling
for splitting a bundle with a fixed constraint from #165 now also takes
loop depth into account.

There are several reasons to do this:
* The original vreg bundle could already have conflicting requirements,
which will cause all merge attempts to fail.
* Failed merges introduce blockparam moves, which often happen in
critical edge blocks. We want to avoid introducing move instructions in
these blocks since they can often be eliminated entirely by jump
threading when empty.
* Conflicting requirements are already handled in the main
bundle processing loop, which will split them at the first conflict
point. This is a much better place at which to insert a move
instruction.

Each merge eliminates the need for one move instruction in the final
program. However a successful merge can cause a future merge to fail
due to interference. Therefore we want to prioritize merges that have
the highest impact:

* We want to eliminate moves in loops that are executed many times.
* We want to eliminate moves in split critical edge blocks, since it
  allows the entire block to be eliminated with jump threading.

A single vreg may have multiple conflicting uses, and
furthemore conflicting uses may be introduced through bundle merging.
Instead of resolving this in the main processing loop, pre-process all
bundles to ensure they have satisfiable requirements.

This is done in a single linear pass over each bundle, with split points
introduced between each pair of conflicting uses.