Provides a function to let us coerce our underlying
`__cuda_array_interface__` objects into something that behaves more like
an array. Prefers CuPy if possible, but will fallback to Numba if its
not available.

To cutdown on the number of send/recv operations and also to transmit
larger amounts of data at a time, this condenses all frames into a host
buffer and a device buffer, which are sent as two separate
transmissions.

No need to concatenate them together in this case.

To optimize concatenation in the case where NumPy and CuPy are around,
just use their `concatenate` functions. However when they are absent
fallback to some hand-rolled concatenate routines.

To optimize the case where NumPy and CuPy are around, simply use their
`split` function to pull apart large frames into smaller chunks.

Make sure that we extract and return the underlying
`DeviceBuffer`s/`memoryview`s.

This limits synchronization to cases where only non-trivial device
buffers are being sent.

This will result in an extra empty frame getting added to the back of
the list of frames, which we don't need. So go ahead and drop the last
length as split already will grab until the end.

As `.copy()` calls `memcpy`, which is synchronous, performance is worse
as we synchronize after copying each part of the buffer. To fix this,
we switch to `cupy.copyto` with calls `memcpyasync`. This lets us avoid
having a synchronize after each copy.

Shouldn't be needed as copying should occur before deletion of the
original buffer as it is stream ordered.