Refactor Decoder trait

[kylebarron]

• Pass in a dataclass of parameters/attributes instead of PhotometricInterpretation and JPEG tables as top-level args
• Pass in output data type?
• Allow returning more strongly-typed data rather than just Vec<u8>, ref Support LERC decompression #154

[feefladder]

One comment on:

* Allow returning more strongly-typed data rather than just `Vec<u8>`, ref [Support LERC decompression #154](https://github.com/developmentseed/async-tiff/issues/154)

I fully support more strongly-typed arrays from decoder. I had a small nitpick in #234, that would be solved by that.

When thinking about a Decoder trait with two possible implementations (typed and not-typed), I couldn't think of a way to implement two different functions bidirectionally. Exposing a fn(buf: &mut [u8]) to Python doesn't work, so I think the trait can be split in two with a blanket implementation:

pub struct DecodingInfo {
  photometric_interpretation: PhotometricInterpretation,
  jpeg_tables: Option<&[u8]>,
  samples_per_pixel: u16,
  bits_per_sample: u16, // this is still needed in case data_type is unknown
  data_type: Option<DataType>,
  n_pixels: usize // the number of pixels in this tile, including padding
}

/// A trait to decode a TIFF tile. This is exposed to Python
pub trait TypedDecoder: Debug + Send + Sync {
    /// Decode a TIFF tile.
    fn decode_tile_typed(
        &self,
        buffer: Bytes,
        decoding_info: DecodingInfo
    ) -> AsyncTiffResult<TypedArray>;
}

/// The trait that all current implementations can easily be modified to implement
pub trait Decoder: Debug + Send + Sync {
    fn decode_tile(
        &self,
        buffer: Bytes,
        out_buffer: &mut[u8],
        decoding_info: DecodingInfo
    ) -> AsyncTiffResult<()>;
}

/// Blanket implementation RawDecoder=>Decoder
impl<T: Decoder> TypedDecoder for T {
    fn decode_tile_typed(
        &self,
        buffer: Bytes,
        decoding_info: DecodingInfo
    ) -> AsyncTiffResult<TypedArray>  {
        let typed_array = TypedArray::new(&decoding_info);
        self.decode_tile_raw(buffer, typed_array.as_mut(), decoding_info)
        typed_array
    }
}

This requires pre-determining the output buffer size as here. And change the (un)predictors to also take in &mut[u8] rather than Vec<u8> to be able to preserve type.

e.g. in tile.decode() from here onwards:

match self.predictor {
            Predictor::None => {
                fix_endianness(
                    decoded_tile.as_mut(),
                    self.predictor_info.endianness(),
                    self.predictor_info.bits_per_sample(),
                );
                Ok(decoded_tile)
            }
            Predictor::Horizontal => {
                unpredict_hdiff(decoded_tile.as_mut(), &self.predictor_info, self.x as _)
            }
            Predictor::FloatingPoint => {
                let in = decoded_tile.clone();
                unpredict_float(in.as_ref(), decoded_tile.as_mut(), &self.predictor_info, self.x as _, self.y as _)
                // truncate decoded_tile to remove padding
            }
        }?;

would a PR like that be welcome?