feat: Refactor Registries

Interface changes:
- Rename StrategySelector to StrategyEncoderRegistry
- Implement clone for SwapEncoder

The StrategyEncoderRegistry needs to be initialised at the highest level and the passed to the TychoEncoder.
The TychoEncoder doesn't hold the chain nor the signer_pk as attributes anymore
The StrategyEncoderRegistry does:
- Initialises the SwapEncoderRegistry
- Initialises all the strategies and saves them in a HashMap
- Later, the TychoEncoder only reads from this hashmap

The StrategyEncoder now each holds a SwapEncoderRegistry as an attribute and they use this to get the correct SwapEncoder instead of reading from the global SWAP_ENCODER_REGISTRY

Simplified the SwapEncoderRegistry to not need a Config (everything is done inside itself)
All SwapEncoders implement clone

Took 2 hours 29 minutes

Took 11 seconds

Took 2 minutes

src/encoding/evm/strategy_encoder/strategy_encoder_registry.rs

@@ -0,0 +1,53 @@
+use std::collections::HashMap;
+
+use tycho_core::models::Chain;
+
+use crate::encoding::{
+    errors::EncodingError,
+    evm::{
+        strategy_encoder::strategy_encoders::{ExecutorStrategyEncoder, SplitSwapStrategyEncoder},
+        swap_encoder::registry::SwapEncoderRegistry,
+    },
+    models::Solution,
+    strategy_encoder::{StrategyEncoder, StrategyEncoderRegistry},
+};
+
+pub struct EVMStrategyEncoderRegistry {
+    strategies: HashMap<String, Box<dyn StrategyEncoder>>,
+}
+
+impl StrategyEncoderRegistry for EVMStrategyEncoderRegistry {
+    fn new(
+        chain: Chain,
+        executors_file_path: &str,
+        signer_pk: Option<String>,
+    ) -> Result<Self, EncodingError> {
+        let swap_encoder_registry = SwapEncoderRegistry::new(executors_file_path, Chain::Ethereum)?;
+
+        let mut strategies: HashMap<String, Box<dyn StrategyEncoder>> = HashMap::new();
+        strategies.insert(
+            "executor".to_string(),
+            Box::new(ExecutorStrategyEncoder::new(swap_encoder_registry.clone())),
+        );
+        if let Some(signer) = signer_pk {
+            strategies.insert(
+                "split_swap".to_string(),
+                Box::new(
+                    SplitSwapStrategyEncoder::new(signer, chain, swap_encoder_registry).unwrap(),
+                ),
+            );
+        }
+        Ok(Self { strategies })
+    }
+    fn get_encoder(&self, solution: &Solution) -> Result<&Box<dyn StrategyEncoder>, EncodingError> {
+        if solution.direct_execution {
+            self.strategies
+                .get("executor")
+                .ok_or(EncodingError::FatalError("Executor strategy not found".to_string()))
+        } else {
+            self.strategies
+                .get("split_swap")
+                .ok_or(EncodingError::FatalError("Split swap strategy not found. Please pass the signer private key to the StrategySelector constructor".to_string()))
+        }
+    }
+}