fix(l1): removed unnecesary state clone (#4117)

After spawned upgrade, there is no need to clone `RLPxConnection` state.
But we left a `clone()` in the code that was causing performance issues
on high load of peer messages.

This was discovered analyzing a flame graph by @juan518munoz :
<img width="2934" height="1598" alt="image"
src="https://github.com/user-attachments/assets/041264cd-63c9-4855-85ad-8d277bdaac8e"
/>


**Description**

This removes the cost of the inner state `clone()` showing some nice
improvement on a high load test (two reth and one ethrex nodes being
spammed by about 10.000 transactions per slot)

Ggas/s on the ethrex node:
After: (the second peak is due to peers disconnecting)
<img width="410" height="299" alt="image"
src="https://github.com/user-attachments/assets/3ef44258-0390-4cff-8083-b96d710f7d53"
/>

Before: (peers remained connected through all the test)
<img width="438" height="300" alt="image"
src="https://github.com/user-attachments/assets/eed2a1b4-3106-4498-8bbc-9d7f994b11e7"
/>

Author: ElFantasma

crates/networking/p2p/rlpx/connection/server.rs

@@ -266,48 +266,48 @@ impl GenServer for RLPxConnection {
         message: Self::CastMsg,
         _handle: &RLPxConnectionHandle,
     ) -> CastResponse {
-        if let InnerState::Established(mut established_state) = self.inner_state.clone() {
+        if let InnerState::Established(ref mut established_state) = self.inner_state {
             let peer_supports_l2 = established_state.l2_state.connection_state().is_ok();
             let result = match message {
                 Self::CastMsg::PeerMessage(message) => {
                     log_peer_debug(
                         &established_state.node,
                         &format!("Received peer message: {message}"),
                     );
-                    handle_peer_message(&mut established_state, message).await
+                    handle_peer_message(established_state, message).await
                 }
                 Self::CastMsg::BackendMessage(message) => {
                     log_peer_debug(
                         &established_state.node,
                         &format!("Received backend message: {message}"),
                     );
-                    handle_backend_message(&mut established_state, message).await
+                    handle_backend_message(established_state, message).await
                 }
                 Self::CastMsg::SendPing => {
-                    send(&mut established_state, Message::Ping(PingMessage {})).await
+                    send(established_state, Message::Ping(PingMessage {})).await
                 }
                 Self::CastMsg::SendNewPooledTxHashes => {
-                    send_new_pooled_tx_hashes(&mut established_state).await
+                    send_new_pooled_tx_hashes(established_state).await
                 }
                 Self::CastMsg::BroadcastMessage(id, msg) => {
                     log_peer_debug(
                         &established_state.node,
                         &format!("Received broadcasted message: {msg}"),
                     );
-                    handle_broadcast(&mut established_state, (id, msg)).await
+                    handle_broadcast(established_state, (id, msg)).await
                 }
                 Self::CastMsg::BlockRangeUpdate => {
                     log_peer_debug(&established_state.node, "Block Range Update");
-                    handle_block_range_update(&mut established_state).await
+                    handle_block_range_update(established_state).await
                 }
                 Self::CastMsg::L2(msg) if peer_supports_l2 => {
                     log_peer_debug(&established_state.node, "Handling cast for L2 msg: {msg:?}");
                     match msg {
                         L2Cast::BatchBroadcast => {
-                            l2_connection::send_sealed_batch(&mut established_state).await
+                            l2_connection::send_sealed_batch(established_state).await
                         }
                         L2Cast::BlockBroadcast => {
-                            l2::l2_connection::send_new_block(&mut established_state).await
+                            l2::l2_connection::send_new_block(established_state).await
                         }
                     }
                 }
@@ -345,15 +345,11 @@ impl GenServer for RLPxConnection {
                     }
                 }
             }
-
-            // Update the state
-            self.inner_state = InnerState::Established(established_state);
-            CastResponse::NoReply
         } else {
             // Received a Cast message but connection is not ready. Log an error but keep the connection alive.
             error!("Connection not yet established");
-            CastResponse::NoReply
         }
+        CastResponse::NoReply
     }
 
     async fn teardown(self, _handle: &GenServerHandle<Self>) -> Result<(), Self::Error> {