[coroutines] Temporaries are not preserved in the symmetric `await-suspend` case

https://godbolt.org/z/3cx1bd111

In this example, `await-suspend` is used in the form `await-suspend.resume()`, however the temporaries created during the evaluation of `await-suspend` are destroyed prior to the call to `resume()`, rather than at the end of the full-expression.

```cpp
#include
#include

struct Tag {
struct promise_type {
Tag get_return_object() { return {}; }
std::suspend_never initial_suspend() { return {}; }
std::suspend_never final_suspend() noexcept { return {}; }
void return_void() {}
void unhandled_exception() {}
};
};

struct S {
~S() { std::cout << "~S()" << std::endl; }
};

struct Awaiter {
auto await_ready() { return false; }
auto await_suspend(auto h, S && = {}) {
std::cout << "suspend" << std::endl;
return h;
}
auto await_resume() {
std::cout << "resume" << std::endl;
}
};

auto await_suspend(auto, S && = {}) {
struct Checker {
auto resume() {
std::cout << "resume" << std::endl;
}
};

std::cout << "suspend" << std::endl;
return Checker{};
}

Tag Coroutine() {
std::cout << "[co_await]" << std::endl;
co_await Awaiter{};

std::cout << "\n[check]" << std::endl;
await_suspend(nullptr).resume();
}

int main() {
Coroutine();
}
```

Output:

```cpp
[co_await]
suspend
~S()
resume

[check]
suspend
resume
~S()
```

Reproduce the coroutine behavior using the Godbolt example at https://godbolt.org/z/3cx1bd111, then trace the compiler's handling of the symmetric await-suspend expression and its temporary lifetime. Done means the temporary is destroyed only at the end of the full-expression, with the output ordering matching the issue's expected behavior.

Written by the indexing model from the issue text.