Refactor API into `into_futures_async_read_seek` and `into_futures_async_read`

[Xuanwo]

Maybe there should be be two impls then. One which supports seek, and one that does not.
We have no need for seek, for example. We just need the latest copy.

Yep, that's a good idea. I think we can introduce an into_futures_async_read_seek. And that's will be a breaking change.

Do you want to work on a fix on this?

Originally posted by @Xuanwo in #6995

[amunra]

I'm not sure I'll be able to find cycles for an actual PR any time soon.
That said, this seems to work in our code base now:

pub struct AsyncReader {
    stream: opendal::BufferStream,
    current: opendal::Buffer,
    eof: bool,
}

impl AsyncReader {
    pub fn new(stream: opendal::BufferStream) -> Self {
        Self {
            stream,
            current: opendal::Buffer::new(),
            eof: false,
        }
    }
}

impl AsyncRead for AsyncReader {
    fn poll_read(
        mut self: Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
        buf: &mut [u8],
    ) -> Poll<io::Result<usize>> {
        if self.eof {
            return Poll::Ready(Ok(0));
        }
        loop {
            match Read::read(&mut self.current, buf) {
                Ok(read) if read > 0 => return Poll::Ready(Ok(read)),
                Ok(_) => (), // fetch next buffer
                Err(err) => {
                    self.eof = true;
                    return Poll::Ready(Err(err));
                }
            };
            let stream = Pin::new(&mut self.stream);
            match futures::stream::Stream::poll_next(stream, cx) {
                Poll::Ready(Some(Ok(buf))) => {
                    self.current = buf;
                }
                Poll::Ready(Some(Err(err))) => {
                    self.eof = true;
                    let io_err: io::Error = err.into();
                    return Poll::Ready(Err(io_err));
                }
                Poll::Ready(None) => {
                    self.eof = true;
                    return Poll::Ready(Ok(0));
                }
                Poll::Pending => return Poll::Pending,
            }
        }
    }
}