### Is there an existing issue for this?

- [X] I have searched the existing issues

### Feature description

Allow lambda container to have multiple networks not just one.
With the current implementation Lambda network only gets a single network, even though the Localstack container accepts multiple network values.
this is how it works currently:

> Gets the main network of the LocalStack container (if we run in one, bridge otherwise)
    If there are multiple networks connected to the LocalStack container, we choose the first as "main" network

### 🧑‍💻 Implementation

This is where the "main" network value is retrieved, may be it should be a List?
https://github.com/localstack/localstack/blob/a71e661fa6b0189e54b468713f710f0ae1b93791/localstack/utils/container_networking.py#L14

### Anything else?

_No response_
self,
        lambda_function: LambdaFunction,
        lambda_docker_ip: Optional[str] = None,
        check_port: bool = False,
    ) -> bool:
        """Return whether to use stay-open execution mode - if we're running in Docker, the given IP
        is defined, and if the target API endpoint is available (optionally, if check_port is True)."""
        if not lambda_docker_ip:
            func_arn = lambda_function.arn()
            container_name = self.get_container_name(func_arn)
            lambda_docker_ip = DOCKER_CLIENT.get_container_ip(container_name_or_id=container_name)
        should_use = lambda_docker_ip and config.LAMBDA_STAY_OPEN_MODE
        if not should_use or not check_port:
            return should_use
        full_url = self._get_lambda_stay_open_url(lambda_docker_ip)
        return is_port_open(full_url)
    def _get_lambda_stay_open_url(self, lambda_docker_ip: str) -> str:
        return f"http://{lambda_docker_ip}:{STAY_OPEN_API_PORT}"
    def _execute(self, func_arn: str, *args, **kwargs) -> InvocationResult:
        if not LAMBDA_CONCURRENCY_LOCK.get(func_arn):
            concurrency_lock = threading.RLock()
            LAMBDA_CONCURRENCY_LOCK[func_arn] = concurrency_lock
        with LAMBDA_CONCURRENCY_LOCK[func_arn]:
            return super(LambdaExecutorReuseContainers, self)._execute(func_arn, *args, **kwargs)
    def startup(self):
        self.cleanup()
        
        if config.LAMBDA_REMOVE_CONTAINERS:
            self.start_idle_container_destroyer_interval()
    def cleanup(self, arn: str = None):