Fix move detection for the last line in an insert group.

The move detection introduced an off-by-one where the last line in a
chunk wasn't being processed as a move unless the line after the chunk
had content. That last line should never have been processed either
in the first place, but we were just looping too hard.

We now loop only through the lines in the chunk, and if we've hit the
line and have any move ranges calculated, we process them.
Fix showing indentation changes on interdiffs in partly-invalid chunks.

When generating interdiffs, we figure out which chunks we actually want
to show any change information for, restricting it to chunks matching
the ranges indicated in the actual diff files.

The problem is, the way this interacts with "equals" computation (where
we strip two otherwise "equal" lines) can cause indentation information
to
be filtered out. This happens because any chunk that isn't completely
within a valid range will get filtered out. Even though an indentation
change is an actual change line, we make it appear as an "equal", which
appears to span beyond those ranges.

To fix this, we needed to break up any chunks sitting on a valid range
boundary, keeping those parts of the chunks and turning the remains into
a filtered-equal chunk.

We then needed to convert the "filtered-equal" chunks to "equal" and
stitch those back together into "equal" chunks later. We already had
processors to do both of these things, but the one for merging adjacent
chunks happened right after interdiff filtering (which was too soon). We
now do this and convert back to "equal" in the post-processing meta
stage. At this stage, we also know about indentation information, so we
can also single those out as their own chunks, sanely.