Use the variant of await_suspend() that returns a
coroutine handle.

If await_suspend() returns a std::coroutine_handle then
this is unconditionally resumed. So we now return a
dummy coroutine_handle whose resume() method just
immediately suspends in cases where there is no
continuation ready to be resumed.

This greatly simplifies the implementation as we don't
need to do anything special for the case where the
async operations complete synchronously.

The async_generator<T> no longer needs atomic operations
to synchronise consumer/produce running concurrently since
one is always suspended before resuming the other.

- recursive_generator's final_suspend now directly resumes
  the parent generator using symmetric control transfer in
  await_suspend() rather than trampolining off a loop in
  the pull() method.
- Recursive yield_value() now has much simpler logic for
  maintaining the root/parent/leaf pointers due to use
  of symmetric transfer meaning we don't have to explicitly
  handle a coroutine completing synchronously.
- yield_value() now stores pointer to value in the root
  generator's m_value. This should make repeated iterator
  dereferences slightly more efficient as the derference
  now has one less pointer dereference (the extra
  dereference is now in the yield_value() method).

Allows co_return'ing a lazy_task<T> instead of a T to perform
tail recursion.