Pretty printer algorithm revamp step 2

[dtolnay]

This PR follows #92923 as a second chunk of modernizations backported from /~https://github.com/dtolnay/prettyplease into rustc_ast_pretty.

I've broken this up into atomic commits that hopefully are sensible in isolation. At every commit, the pretty printer is compilable and has runtime behavior that is identical to before and after the PR. None of the refactoring so far changes behavior.

The general theme of this chunk of commits is: the logic in the old pretty printer is doing some very basic things (pushing and popping tokens on a ring buffer) but expressed in a too-low-level way that I found makes it quite complicated/subtle to reason about. There are a number of obvious invariants that are "almost true" -- things like self.left == self.buf.offset and self.right == self.buf.offset + self.buf.data.len() and self.right_total == self.left_total + self.buf.data.sum(). The reason these things are "almost true" is the implementation tends to put updating one side of the invariant unreasonably far apart from updating the other side, leaving the invariant broken while unrelated stuff happens in between. The following code from master is an example of this:

rust/compiler/rustc_ast_pretty/src/pp.rs

Lines 314 to 317 in e5e2b0b

	self.advance_right();
	}
	self.check_stack(0);
	self.scan_push(BufEntry { token: Token::Break(b), size: -self.right_total });

In this code the advance_right is reserving an entry into which to write a next token on the right side of the ring buffer, the check_stack is doing something totally unrelated to the right boundary of the ring buffer, and the scan_push is actually writing the token we previously reserved space for. Much of what this PR is doing is rearranging code to shrink the amount of stuff in between when an invariant is broken to when it is restored, until the whole thing can be factored out into one indivisible method call on the RingBuffer type.

The end state of the PR is that we can entirely eliminate self.left (because it's now just equal to self.buf.offset always) and self.right (because it's equal to self.buf.offset + self.buf.data.len() always) and the whole Token::Eof state which used to be the value of tokens that have been reserved space for but not yet written.

I found without these changes the pretty printer implementation to be hard to reason about and I wasn't able to confidently introduce improvements like trailing commas in prettyplease until after this refactor. The logic here is 43 years old at this point (Graydon translated it as directly as possible from the 1979 pretty printing paper) and while there are advantages to following the paper as closely as possible, in prettyplease I decided if we're going to adapt the algorithm to work better for Rust syntax, it was worthwhile making it easier to follow than the original.

[rust-highfive]

r? @lcnr

(rust-highfive has picked a reviewer for you, use r? to override)

[lcnr]

that is a very clean commit history, thanks ❤️ would have taken me far longer to review this otherwise

@bors r+ rollup

[bors]

📌 Commit 4d3faae has been approved by lcnr