Feat: add Mutex::lock_owned and Mutex::try_lock_owned

[Sherlock-Holo]

Add 2 new methods Mutex::lock_owned and Mutex::try_lock_owned

People who like #1972 want a new method such as poll_lock, to help them implement Future easier and less overhead. But adding poll_lock new method is so hard for the currently Mutex implementation.

However, if #1972 can store the future which returned by Mutex::lock, it can poll the future when poll its MyReceiver. Currently, the Mutex only has lock and try_lock method, which use the &self and the lock return a future but it has a reference to the Mutex. If save the mutex and its MutexLockFuture in a struct, will meet the self-reference problem.

To solve the self-reference problem, add a new way to lock the mutex: Mutex::lock_owned(self: &Arc<Self>) -> OwnedMutexLockFuture<T>, the OwnedMutexLockFuture doesn't reference any variable, it contains the mutex which wrapped by the Arc, so the self-reference problem disappears.

with this PR, #1972 can rewrite like

use futures::lock::Mutex;

struct MySender {
    inner: Arc<Mutex<Inner>>,
}

struct MyReceiver {
    inner: Arc<Mutex<Inner>>,
    fut: Option<OwnedMutexLockFuture<Inner>>,
    guard: Option<OwnedMutexGuard<Inner>>,
}

impl Future for MyReceiver {
    type Output = ();

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
        let this = self.get_mut();

        loop {
            if let Some(_guard) = this.guard.as_mut() {
                todo!()
            } else { 
                match this.fut.as_mut() {
                    None => {
                        this.fut.replace(this.inner.lock_owned());
                    }
                    Some(fut) => {
                        let guard = futures_core::ready!(Pin::new(fut).poll(cx));

                        this.guard.replace(guard);
                    }
                }
            }
        }
    }
}

[taiki-e]

Thanks!