Adding a drop impl breaks drop order

[main--]

struct Context;

struct Foo<'a>(&'a Context);
struct Bar<'a>(&'a Foo<'a>);
struct Baz<'a>(&'a Context);

impl<'a> Drop for Baz<'a> {
    fn drop(&mut self) {
    }
}

impl<'a> Bar<'a> {
    fn next(&mut self) -> Option<Baz<'a>> {
        None
    }
}

fn util(ctx: &Context) {
    let foo = Foo(ctx);
    let mut bar = Bar(&foo);
    
    match bar.next() { _ => () } // this fails
    // return match bar.next() { _ => () }; // this works
}

error: `foo` does not live long enough
  --> <anon>:24:1
   |
20 |     let mut bar = Bar(&foo);
   |                        --- borrow occurs here
...
24 | }
   | ^ `foo` dropped here while still borrowed
   |
   = note: values in a scope are dropped in the opposite order they are created

error: aborting due to previous error

Playground

Note how the message even states that bar is dropped first (reverse order) while complaining that it outlives foo.

This works fine if you remove Baz's Drop impl or - interestingly - if you just use the return keyword instead of "naturally" returning the value.

[Stebalien]

Probably a duplicate of #17462 (scratch that, not related), #22449, and #21114. May also be related to #22321. I thought there was a more "canonical" issue for this but I can't find it.

[Mark-Simulacrum]

Yes, closing in favor of #21114.