feat(da-throttling): Introduce DA throttling via the MinerAPI

[0xKitsune]

This PR introduces DA throttling to rollup-boost as well as fixes RPC module initialization. Note that this PR builds on #61, incorporating its changes.

Closes #48

This PR introduces DA throttling by implementing the MinerApiExtServer as an RPC module. Additionally, a MinerApi trait has been implemented for the remaining miner_ RPC endpoints. Tests were added for all newly introduced RPC modules.

While Reth provides a MinerApi, it is synchronous where rollup-boost requires an async implementation. To address this we recreated the trait within rollup-boost and can upstream this to Reth, allowing us to switch to reth-rpc-api once an async version is available.

Since the auth_rpc does not expose the Miner API, we introduced a new ExecutionClient struct to orchestrate requests to either the authenticated Engine API (via auth_client) or the JSON-RPC API (via client).

/// Client interface for interacting with an execution layer node.
///
/// - **Engine API** calls are faciliated via the `auth_client` (requires JWT authentication).
/// -  All other API calls including the **Eth & Miner APIs** are faciliated via the `client` (optional JWT authentication).
///
#[derive(Clone)]
pub struct ExecutionClient<C: ClientT = HttpClient<HttpBackend>> {
    /// Handles requests to Eth, Miner, and other execution layer APIs (optional JWT authentication)
    pub client: Arc<C>,
    /// Address of the RPC server for execution layer API calls, excluding the Engine API
    pub http_socket: SocketAddr,
    /// Handles requests to the authenticated Engine API (requires JWT authentication)
    pub auth_client: Arc<HttpClient<AuthClientService<HttpBackend>>>,
    /// Address of the RPC server for authenticated Engine API calls
    pub auth_socket: SocketAddr,
}

Fixes #63

Previously,the only RPC methods initialized were from the Engine API. This has been updated to ensure that EthApiServer, MinerApiServer, and MinerApiExtServer are properly merged into the RPC module.

// --snip--
fn try_into(self) -> Result<RpcModule<()>, Self::Error> {
    let mut module: RpcModule<()> = RpcModule::new(());
    module.merge(EngineApiServer::into_rpc(self.clone()))?;
    module.merge(EthApiServer::into_rpc(self.clone()))?;
    module.merge(MinerApiServer::into_rpc(self.clone()))?;
    module.merge(MinerApiExtServer::into_rpc(self))?;

    Ok(module)
}

Addresses #65

Since we introduced a client and auth_client for each execution client, we made a small update to the proxy logic to ensure that all non-multiplexed methods are routed to the auth RPC of the default L2 client with the proper authorization header.