Exposing stride and integration with `imgref`

[madsmtm]

We currently expose a Buffer<'_> with .width(), .height() and DerefMut<Target = [u32]>, but for implementing zero-copy, we need to expose a .stride() method as well, see #95. And while we're doing that, it'd be nice to add some helper methods like .rows() to make iteration a bit less cumbersome.

Surprise surprise, there's already a library for this! It's called imgref.

Naively, we'd like to just add impl<'a> DerefMut<Target = Img<&'a mut [u32]> for Buffer<'a, ...>, but that unfortunately won't work, since the way Deref/DerefMut is designed they require that we can actually produce a reference to them, and this can be somewhat difficult in this case since Img takes control over how the pointer is stored.

For example, consider WaylandBuffer as currently implemented:

struct WaylandBuffer {
    map: MmapMut,
    pub width: i32,
    pub height: i32,
    // ... Other fields.
}

impl Deref for WaylandBuffer {
    type Target = Img<&'unclear_lifetime mut [u32]>;
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut Img::new(self.map.as_mut(), self.width, self.height)
        // Won't work, the reference escapes the context.
    }
}

As far as I can tell, there isn't really a way to resolve this, at least not without larger changes to either Softbuffer or imgref?

[madsmtm]

An alternative design in Softbuffer that still uses imgref may be something like:

impl Surface<D, W> {
    pub fn data(&mut self) -> Result<imgref::Img<Buffer<'_, D, W>>, SoftBufferError> { todo!() }
}

// Usage
let data = surface.data().unwrap();
for (y, row) in data.rows_mut().enumerate() {
    for (x, value) in row.iter_mut().enumerate() {
        let red = x % 255;
        let green = y % 255;
        let blue = (x * y) % 255;
        *value = blue | (green << 8) | (red << 16);
    }
}
data.into_buf().present().unwrap();

But that'd require a few changes to imgref to support arbitrary container types in rows_mut, and the .into_buf() feels a bit yucky.

[madsmtm]

I'm leaning towards instead re-implementing relevant helpers from imgref ourselves. From what I can tell, the most important ones are:

• stride(&self) -> u32
• rows_mut(&mut self) -> impl Iterator<Item = &mut [u32]>
• pixels_mut(&mut self) -> impl Iterator<Item = &mut u32>

(It'd probably also be useful with similar helpers for dealing with damage regions, though I'm unsure of how those would look).