Issue Description:

ManagedBuffer and ManagedBufferPointer restrict access to their elements via methods that take closures. I assume this is done to prevent the caller from having to worry about the buffer lifetime.

The problem is this means I can't use read/modify coroutines to yield elements (e.g. as the subscript for a custom collection type). I know they're not stable yet (at least in Swift 5.3) but I'd really like to use them anyway because of performance concerns. And right now my only choice is to have the coroutine move the element onto the stack, yield it, and then move it back into the managed buffer. Since my collection type is generic this means I have no way to make an informed choice as to whether moving the element back and forth is better or worse than just using get/set.

I don't know how the coroutines are implemented, but I assume it's not feasible to make yield work from inside a nested closure. Given that, I think the best solution here is to just give me a way to address elements of a ManagedBuffer or ManagedBufferPointer directly. This could look something like

extension ManagedBufferPointer {
    subscript(unsafeElementAt offset: Int) -> Element {
        _read {
            yield _elementPointer[offset]
        }
        nonmutating _modify {
            yield &_elementPointer[offset]
        }
    }
}

This way I can then yield &buffer[unsafeElementAt: offset] in my own _modify and I won't run into this issue. It would also simplify the get/set case because it turns return buffer.withUnsafeMutablePointerToElements({ $0[offset] }) into return buffer[unsafeElementAt: offset].