Add a lint for unbound mutex guards

What it does

When working with various synchronization primitives, such as Mutex and RwLock, it is easy to make the mistake of not binding the corresponding guard to the current scope. It would be helpful to assist.

Advantage

No response

Drawbacks

No response

Example

struct Worker {
    mutex: std::sync::Arc<std::sync::Mutex<()>>,
}

impl Worker {
    fn work(&self) {
        let _ = self.mutex.lock().unwrap();
        // Do some work with an external resource.
    }
}

struct AsyncWorker {
    mutex: std::sync::Arc<tokio::sync::Mutex<()>>,
}

impl AsyncWorker {
    async fn work(&self) {
        let _ = self.mutex.lock().await;
        // Do some work with an external resource.
    }
}

Could be written as:

struct Worker {
    mutex: std::sync::Arc<std::sync::Mutex<()>>,
}

impl Worker {
    fn work(&self) {
        let _guard = self.mutex.lock().unwrap();
        // Do some work with an external resource.
    }
}

struct AsyncWorker {
    mutex: std::sync::Arc<tokio::sync::Mutex<()>>,
}

impl AsyncWorker {
    async fn work(&self) {
        let _guard = self.mutex.lock().await;
        // Do some work with an external resource.
    }
}

Review the Mutex and RwLock examples in the issue and compare them with existing Clippy lint patterns. Define which discarded guard expressions and synchronization primitives should be covered, then add coverage for the supported cases and verify that intentional temporary locks are handled appropriately. Done means the lint reliably flags unbound guards without introducing false positives.