Not sure this is ready, but it seems to handle everything I've thrown at it.

In an effort to test it, I came up with this silly example:

pub fn marker() {}

pub fn shortcircuit_and(a: bool, b: bool) {
    if a && b {
        marker();
    }
}

pub fn nested_while_loop(a: bool, b: bool) {
    while a {
        let mut i = 0;
        loop {
            marker();
            match i {
                0 | 1 | 2 | 4 => {}
                5 => break,
                _ => continue,
            }
            marker();
            i += 1;
        }
        if a & b {
            break;
        }
        if a | b {
            return;
        }
        while b {
            marker();
        }
    }
}

I was inspired by the loop-specific solution of "threading all exits through one break (with a tag indicating which to take when outside the loop)" and tried to extend it to handle non-structural acyclic branches as well - the result is this PR.

You can see all the OpPhis, which are used to decide whether a "deferred exit" executes, when it's finally "fully accounted for" (or "owned"? not sure what the best terminology is) by a "region".

Most of the implementation is a SEME -> SESE propagation (with the aforementioned "deferred exits"), which is then used to handle both acyclic and cyclic "regions".