print: align adjacent multi-version columns' lines, to match up their anchors.

[eddyb]

This extra step, just before turning multi-version pretty-printed fragments into a HTML table row, allows for a clearer visual match between the columns, turning the multi-version mode into something closer to a pass "differ", but the use of anchors (instead of line contents) makes it more conservative, reliable and somewhat simpler.

In short, if two adjacent versions contain a definition like v123 = ..., it should now end up on the same horizontal line in both versions (assuming it's not e.g. out of order wrt most of the other definitions).

Before, adding or removing instructions (or even their pretty-printing needing different line amounts) would result in one side being behind (and the other, ahead), which would accumulate (even if most of their contents might be similar or even identical). With this PR, a lot of that should be alleviated, as padding (of empty lines) is added to keep both versions aligned as much as possible.

---

However, while it works great for correcting small misalignments (the original usecase), it's quite zealous (and lacks any heuristics or further constraint-solving etc.), leading to results like this:

Before (click for complete pretty HTML example)
After (click for complete pretty HTML example)

This is for the same SPIR-T as the last screenshot from the Rust-GPU reduce+fuse_selects PR.

The OpNops don't help (and those should be gone once SPIR-T APIs are adjusted), but it's generally much worse looking than I was hoping. Maybe it's worth it for the ability, but some things are just annoying.

Based on this screenshot alone, several possible further improvements come to mind:
_{(EDIT: several of these have been implemented in this PR since it was opened)}

• hidden anchors could be added for e.g. ControlNodes and ControlRegions, even if there's not necessarily any syntax to attach them to (other than the keyword for non-Block ControlNodes and the {...} brackets for ControlRegion?)
• the contents of the aligned lines could be compared and some kind of graying/translucency used to de-emphasize the lines that haven't changed
  • there's a risk here of making them confused with removed lines
    • this is where merely partial grayscaling, or some kind of sepia effect, might come in handy
  • such diff-like mode could supplant the use of colspan entirely, and allow horizontal scrolling of the whole table, with the max line length being used to size the cells (e.g. td { max-width: 100ch; }), instead of divvying up the whole viewport width
  • _{may need some level of interactivity (based on which column is being hovered on?)}
• Rust-GPU's --spirt-dump-passes could skip the unstructured control-flow column, which adds a bunch of gaps for no good reason (or it could be kept but with the alignment turned off?)
• _{euristics (or just more user control) to avoid large gaps}
• _{some additional "layout" pass could rearrange all the lines that are "floating" in between anchors}
  • _{crucially, the current state is that the new vertical gaps are always inserted just before the anchor, and never elsewhere, but the lines before the anchor might be more "attached" to it than the ones after
    (sadly, we can't just switch where the vertical gap goes unconditionally: anchors can easily precede multiple-line contents that should not be broken up)}
  • _{e.g. ideally the vertical gap would be at the outermost indentation level, which would allow e.g. structured control-flow to "coalesce together" (may require either using LineOp more directly, or just making indentation special in TextOp)}
  • _{it almost feels like this requires a redesign of a bunch of the print::pretty layout, to allow "flexible vertical spacing", which frankly seems like overkill}
• _{dynamic control over the HTML table via JS, to allow user adjustments on the fly}
  • _{some part of the anchor alignment algorithm would likely need to be implemented in JS, to avoid the combinatorial explosion in the data that would need to be statically generated otherwise}