Clippy 1.67 (#3916)

## Proposed Changes

Clippy 1.67.0 put us on blast for the size of some of our errors, most of them written by me ( 👀 ). This PR shrinks the size of `BeaconChainError` by dropping some extraneous info and boxing an inner error which should only occur infrequently anyway.

For the `AttestationSlashInfo` and `BlockSlashInfo` I opted to ignore the lint as they are always used in a `Result<A, Info>` where `A` is a similar size. This means they don't bloat the size of the `Result`, so it's a bit annoying for Clippy to report this as an issue.

I also chose to ignore `clippy::uninlined-format-args` because I think the benefit-to-churn ratio is too low. E.g. sometimes we have long identifiers in `format!` args and IMO the non-inlined form is easier to read:

```rust
// I prefer this...
format!(
    "{} did {} to {}",
    REALLY_LONG_CONSTANT_NAME,
    ANOTHER_REALLY_LONG_CONSTANT_NAME,
    regular_long_identifier_name
);
  
// To this
format!("{REALLY_LONG_CONSTANT_NAME} did {ANOTHER_REALLY_LONG_CONSTANT_NAME} to {regular_long_identifier_name}");
```

I tried generating an automatic diff with `cargo clippy --fix` but it came out at:

```
250 files changed, 1209 insertions(+), 1469 deletions(-)
```

Which seems like a bad idea when we'd have to back-merge it to `capella` and `eip4844` 😱

beacon_node/beacon_chain/src/attestation_verification.rs

@@ -27,6 +27,11 @@
 //!                                ▼
 //!                  impl VerifiedAttestation
 //! ```
+
+// Ignore this lint for `AttestationSlashInfo` which is of comparable size to the non-error types it
+// is returned alongside.
+#![allow(clippy::result_large_err)]
+
 mod batch;
 
 use crate::{

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -975,7 +975,9 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             .ok_or(Error::ExecutionLayerMissing)?
             .get_payload_by_block_hash(exec_block_hash)
             .await
-            .map_err(|e| Error::ExecutionLayerErrorPayloadReconstruction(exec_block_hash, e))?
+            .map_err(|e| {
+                Error::ExecutionLayerErrorPayloadReconstruction(exec_block_hash, Box::new(e))
+            })?
             .ok_or(Error::BlockHashMissingFromExecutionLayer(exec_block_hash))?;
 
         // Verify payload integrity.
@@ -992,8 +994,6 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             return Err(Error::InconsistentPayloadReconstructed {
                 slot: blinded_block.slot(),
                 exec_block_hash,
-                canonical_payload_root: execution_payload_header.tree_hash_root(),
-                reconstructed_payload_root: header_from_payload.tree_hash_root(),
                 canonical_transactions_root: execution_payload_header.transactions_root,
                 reconstructed_transactions_root: header_from_payload.transactions_root,
             });

beacon_node/beacon_chain/src/block_verification.rs

@@ -42,6 +42,11 @@
 //!            END
 //!
 //! ```
+
+// Ignore this lint for `BlockSlashInfo` which is of comparable size to the non-error types it is
+// returned alongside.
+#![allow(clippy::result_large_err)]
+
 use crate::eth1_finalization_cache::Eth1FinalizationData;
 use crate::execution_payload::{
     is_optimistic_candidate_block, validate_execution_payload_for_gossip, validate_merge_block,

beacon_node/beacon_chain/src/errors.rs

@@ -141,13 +141,11 @@ pub enum BeaconChainError {
     BuilderMissing,
     ExecutionLayerMissing,
     BlockVariantLacksExecutionPayload(Hash256),
-    ExecutionLayerErrorPayloadReconstruction(ExecutionBlockHash, execution_layer::Error),
+    ExecutionLayerErrorPayloadReconstruction(ExecutionBlockHash, Box<execution_layer::Error>),
     BlockHashMissingFromExecutionLayer(ExecutionBlockHash),
     InconsistentPayloadReconstructed {
         slot: Slot,
         exec_block_hash: ExecutionBlockHash,
-        canonical_payload_root: Hash256,
-        reconstructed_payload_root: Hash256,
         canonical_transactions_root: Hash256,
         reconstructed_transactions_root: Hash256,
     },

beacon_node/beacon_chain/src/fork_choice_signal.rs

@@ -43,7 +43,7 @@ impl ForkChoiceSignalTx {
     ///
     /// Return an error if the provided `slot` is strictly less than any previously provided slot.
     pub fn notify_fork_choice_complete(&self, slot: Slot) -> Result<(), BeaconChainError> {
-        let &(ref lock, ref condvar) = &*self.pair;
+        let (lock, condvar) = &*self.pair;
 
         let mut current_slot = lock.lock();
 
@@ -72,7 +72,7 @@ impl Default for ForkChoiceSignalTx {
 
 impl ForkChoiceSignalRx {
     pub fn wait_for_fork_choice(&self, slot: Slot, timeout: Duration) -> ForkChoiceWaitResult {
-        let &(ref lock, ref condvar) = &*self.pair;
+        let (lock, condvar) = &*self.pair;
 
         let mut current_slot = lock.lock();