Add conversions from Arc<Mutex> and Arc<RwLock> wrappers

[Luthaf]

This allows sharing data that can be modified both by Rust and the DlPack consumer, using locks to enforce borrowing rules at runtime.

We store both the Arc<Lock> and the LockGuard<'a> in the DLPack context to ensure that we both keep the data alive in the Arc, and hold the corresponding lock. The resulting self-referential struct (i.e. struct that borrows itself) is created through ouroboros.

[HaoZeke]

TBH I don't like ouroboros. It's a lot of codegen for what I'd think should be maybe handled with simpler lifetime transmute? like

struct ManagerContextMutex<T: 'static> {
    // guard declared before _arc
    // since drops are in declaration order.
    guard: MutexGuard<'static, Vec<T>>,
    _arc: Arc<Mutex<Vec<T>>>,
    shape: i64,
    stride: i64,
}

and then maybe just

fn try_from(array: Arc<Mutex<Vec<T>>>) -> Result<DLPackTensor, Self::Error> {
    let guard = array.lock()?;           // single lock
    let shape = guard.len() as i64;      // extract while locked

    // SAFETY: guard borrows from Mutex inside Arc (heap-allocated).
    // Moving Arc doesn't invalidate the guard's internal pointer.
    // Field drop order: guard drops before _arc.
    let guard: MutexGuard<'static, Vec<T>> = unsafe {
        std::mem::transmute(guard)
    };

    let mut ctx = Box::new(ManagerContextMutex {
        guard, _arc: array, shape, stride: 1,
    });
    // ... extract pointers, build DLTensor
}

[Luthaf]

In my understanding, self referential structs are a very unsafe footgun, and I'd rather delegate support to an external crate for this.

[HaoZeke]

Excellent.

[HaoZeke]

Feel free to merge after the typo fix