chore(ci): bump the pinned nightly to 2026-08-09

`RUST_NIGHTLY_VERSION` drives every job in `ci.yml` — build, clippy,
fmt, tests, doc tests and the AFL fuzzer — not just the doc build its
comment claimed. It had drifted six months behind the toolchain the
downstream consumers of this crate build on, so vm2 was never exercised
on the compiler its users actually use.

The crate already builds on the new nightly; only clippy failed, on
eight pedantic findings in five files:

- `chunks_exact_to_as_chunks` in `Program::new` — `as_chunks::<8>()` /
  `as_chunks::<32>()`. The 8-byte case also drops a `try_into().unwrap()`,
  which in turn makes the `#[allow(clippy::missing_panics_doc)]` on that
  function stale, so it goes too (verified: clippy is clean without it).
- `redundant_else` in `encode_static_gas_cost` — folded the diverging
  `if`/`else` into an `assert!`. Written as `assert!` rather than a bare
  `if ... panic!` because the latter trips `manual_assert`, also pedantic.
- `assert_is_empty` (2), `manual_assert_eq` (1) and
  `unnecessary_trailing_comma` (2) in test and mock code.

No behaviour change.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: 0xVolosnikov

.github/workflows/ci.yml

@@ -10,8 +10,10 @@ on:
 
 env:
   CARGO_TERM_COLOR: always
-  # Nightly Rust necessary for building docs.
-  RUST_NIGHTLY_VERSION: nightly-2026-02-10
+  # Pinned nightly used by every job below (build, clippy, fmt, tests, docs,
+  # fuzzing), not just the doc build. Kept in step with the toolchain the
+  # downstream consumers of this crate build on.
+  RUST_NIGHTLY_VERSION: nightly-2026-08-09
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}

crates/vm2/src/addressing_modes.rs

@@ -139,11 +139,8 @@ impl Arguments {
             INVALID_INSTRUCTION_COST => 4,
             1..=4 => panic!("Reserved gas cost values overlap with actual gas costs"),
             x => {
-                if x > u8::MAX as u32 {
-                    panic!("Gas cost doesn't fit into 8 bits");
-                } else {
-                    x as u8
-                }
+                assert!(x <= u8::MAX as u32, "Gas cost doesn't fit into 8 bits");
+                x as u8
             }
         }
     }

crates/vm2/src/program.rs

@@ -53,18 +53,20 @@ impl<T, W> fmt::Debug for Program<T, W> {
 
 impl<T: Tracer, W: World<T>> Program<T, W> {
     /// Creates a new program.
-    #[allow(clippy::missing_panics_doc)] // false positive
     pub fn new(bytecode: &[u8], enable_hooks: bool) -> Self {
+        let (words, _) = bytecode.as_chunks::<8>();
         let instructions = decode_program(
-            &bytecode
-                .chunks_exact(8)
-                .map(|chunk| u64::from_be_bytes(chunk.try_into().unwrap()))
+            &words
+                .iter()
+                .copied()
+                .map(u64::from_be_bytes)
                 .collect::<Vec<_>>(),
             enable_hooks,
         );
-        let code_page = bytecode
-            .chunks_exact(32)
-            .map(U256::from_big_endian)
+        let (cells, _) = bytecode.as_chunks::<32>();
+        let code_page = cells
+            .iter()
+            .map(|cell| U256::from_big_endian(cell))
             .collect::<Vec<_>>();
         Self {
             instructions: instructions.into(),

crates/vm2/src/single_instruction_test/print_mock_info.rs

@@ -39,10 +39,10 @@ impl<T: Tracer, W: World<T>> State<T, W> {
 impl<T, W> Callframe<T, W> {
     pub(crate) fn print_mock_info(&self) {
         if let Some((address, (value, tag))) = self.stack.read_that_happened() {
-            println!("  {value:?} (is_pointer: {tag}) read from stack address {address}",);
+            println!("  {value:?} (is_pointer: {tag}) read from stack address {address}");
         }
         if let Some((address, (value, tag))) = self.stack.write_that_happened() {
-            println!("  {value:?} (is_pointer: {tag}) written to stack address {address}",);
+            println!("  {value:?} (is_pointer: {tag}) written to stack address {address}");
         }
     }
 }

crates/vm2/src/single_instruction_test/stack.rs

@@ -55,7 +55,7 @@ impl Stack {
 
     fn assert_write_to_same_slot(&mut self, slot: u16) {
         if let Some(last_slot) = self.slot_written {
-            assert!(last_slot == slot);
+            assert_eq!(last_slot, slot);
         }
         self.slot_written = Some(slot);
     }

crates/vm2/src/world_diff.rs

@@ -984,8 +984,8 @@ mod tests {
         world_diff.rollback(snapshot);
 
         // The per-access trace is empty — the whole point of opting out.
-        assert!(world_diff.storage_log_queries().is_empty());
-        assert!(world_diff.rollback_storage_logs.is_empty());
+        assert_eq!(world_diff.storage_log_queries(), []);
+        assert_eq!(world_diff.rollback_storage_logs.as_slice(), []);
 
         // ...but the maps a re-execution verifier derives the deduplicated set
         // from are still populated: the slot needs a protective read (read at