Feat: Add clippy stackslib, pass indexing_slicing

[kantai]

This gets stackslib to pass the first lint listed in #6156

This does a couple of things in the refactor beyond just replacing foo[..] with foo.get(..)? in order to make the usage a little more idiomatic in rust:

• More usage of TryInto<[u8; T]> -- we previously did a lot of buffering in our codebase to get from &[u8] into a [u8; T]. This not only involves indexing or invocations of copy_from_slice(), but it also is less performant.
• More reliance on iterator operations like .take(), .chunks(), .zip(), and .skip(), etc.

Some of the previous avoidance of iterators (in MARF in particular) had comments indicating that iterators were slower than the alternatives (for loops, and even manual for loops). I'm not sure if that used to be the case in older versions of rustc, but as of this PR, there was no measurable difference when measured using the MARF benchmarks (with optimizations turned on: I think in unoptimized builds, there is a performance difference).

[hstove]

LGTM!

[hstove]

nit

Suggested change

	for _sample in burn_sample.iter() {
	for sample in burn_sample.iter() {

[kantai]

I think it should stay _sample because its only ever used in the test_debug!() macro, which is elided in non-test builds.

[hstove]

TIL about chunks_exact, which cleans this up and avoids skipping clippy. Thanks, LLM.

Also, TIL about stacks_common::util::uint. Was this just before there were better uint helpers in Rust std?

 pub fn to_uint256(&self) -> Uint256 {
      let tmp = self
          .0
          .chunks_exact(8)
          .map(|chunk| u64::from_le_bytes(chunk.try_into().unwrap()))
          .collect::<Vec<u64>>();
      Uint256(tmp.try_into().unwrap())
  }

[kantai]

Yes -- though maybe even as_chunks is the best thing here:

    pub fn to_uint256(&self) -> Uint256 {
        let (u64_chunks, []) = self.0.as_chunks::<8>() else {
            panic!("SortitionHash was not evenly divisible by 8")
        };

        let tmp: Vec<u64> = u64_chunks.iter().map(|chunk| u64::from_le_bytes(*chunk)).collect();
        Uint256(tmp.try_into().expect("SortitionHash should have 4 chunks of 8 bytes"))
    }

This is brand new in stable rust (as in, today's release). It creates arrays from constant-sized chunks. It's like the chunks iterator, but it returns arrays instead of slices and it doesn't need to be an iterator, because the arrays are all guaranteed to be inline.

[Jiloc]

lgtm!

[Jiloc]

lgtm after the clippy warning is fixed!