### Is there an existing issue for this?

- [X] I have searched the existing issues

### Current Behavior

Publishing multiple messages to SNS topic with batching, using PublishBatch() API, is much slower than calling N times Publish() API.
The more SQS queues is subscribed to the SNS topic the longer is publishing time with batching - dependency is linear. For individual messages publishing time is independent on number of queues.

### Expected Behavior

Publishing messages to SNS topic with batching should be faster than publishing messages individually and publishing time should be independent on number of SQS queues subscribed to SNS topic - like with AWS.

### How are you starting LocalStack?

With a `docker run` command

### Steps To Reproduce

#### How are you starting localstack (e.g., `bin/localstack` command, arguments, or `docker-compose.yml`)

    docker run -p 4566:4566 --rm -e SERVICES=sqs,sns -e EAGER_SERVICE_LOADING=1 localstack/localstack:1.1.0

#### Client commands (e.g., AWS SDK code snippet, or sequence of "awslocal" commands)

AWS SDK code snippet to show the issue:
````
static async Task TestSNSPublishing()
{
    const int numMsgs = 10;
    string msg = new string('x', 100);

    Stopwatch sw = new Stopwatch();
    using (AmazonSQSClient SQS = new AmazonSQSClient("ignore", "ignore", new AmazonSQSConfig { ServiceURL = "http://localhost:4566" }))
    using (AmazonSimpleNotificationServiceClient SNS = new AmazonSimpleNotificationServiceClient("ignore", "ignore", new AmazonSimpleNotificationServiceConfig { ServiceURL = "http://localhost:4566" }))
    {
        // Create a topic
        CreateTopicResponse createTopicResp = await SNS.CreateTopicAsync("testTopic");

        // Create and subscribe queues to the topic
        CreateQueueResponse createQueueResp1 = await SQS.CreateQueueAsync($"testQueue_{Guid.NewGuid()}");
        string subscriptionArn1 = await SNS.SubscribeQueueAsync(createTopicResp.TopicArn, SQS, createQueueResp1.QueueUrl);
        CreateQueueResponse createQueueResp2 = await SQS.CreateQueueAsync($"testQueue_{Guid.NewGuid()}");
        string subscriptionArn2 = await SNS.SubscribeQueueAsync(createTopicResp.TopicArn, SQS, createQueueResp2.QueueUrl);

        // Publish messages individually
        Task<PublishResponse>[] publTasks = new Task<PublishResponse>[numMsgs];
        sw.Start();
        for (int i = 0; i < numMsgs; i++)
        {
            publTasks[i] = SNS.PublishAsync(createTopicResp.TopicArn, msg);
        }
        await Task.WhenAll(publTasks);
        sw.Stop();
        Console.WriteLine($"Individual: Num. messages = {numMsgs} Publishing time = {sw.ElapsedMilliseconds} ms");

        await Task.Delay(1000);

        // Publish batch of messages
        PublishBatchRequest pubReq = new PublishBatchRequest() { TopicArn = createTopicResp.TopicArn };
        for (int msgId = 0; msgId < numMsgs; msgId++)
        {
            pubReq.PublishBatchRequestEntries.Add(new PublishBatchRequestEntry() { Id = msgId.ToString(), Message = msg });
        }
        sw.Restart();
        await SNS.PublishBatchAsync(pubReq);
        sw.Stop();
        Console.WriteLine($"Batch: Num. messages = {numMsgs} Publishing time = {sw.ElapsedMilliseconds} ms");

        // Cleanup subscriptions and queues
        await SNS.UnsubscribeAsync(subscriptionArn1);
        await SNS.UnsubscribeAsync(subscriptionArn2);
        await SNS.DeleteTopicAsync(createTopicResp.TopicArn);
        await SQS.DeleteQueueAsync(createQueueResp1.QueueUrl);
        await SQS.DeleteQueueAsync(createQueueResp2.QueueUrl);
    }
}
````

Results look as follows:
````
For 2 queues:
Individual: Num. messages = 10 Publishing time = 73 ms
Batch: Num. messages = 10 Publishing time = 443 ms
````
![image](https://user-images.githubusercontent.com/7330332/190376065-90cd8601-8ce7-4079-b8b0-672c0a58541f.png)

For AWS:
````
For 2 queues:
Individual: Num. messages = 10 Publishing time = 501 ms
Batch: Num. messages = 10 Publishing time = 153 ms
````
![image](https://user-images.githubusercontent.com/7330332/190376326-560a5219-37ed-453c-b981-efaeec48622d.png)

### Environment

```markdown
- OS: Win 10 / .NET 6
- LocalStack: 1.1.0
- AWS SDK SNS 3.7.4.3
- AWS SDK SQS 3.7.2.100
```


### Anything else?

_No response_
return str(self.__dict__)
def eval_log_type(env_var_name):
    """get the log type from environment variable"""
    ls_log = os.environ.get(env_var_name, "").lower().strip()
    return ls_log if ls_log in LOG_LEVELS else False
def is_env_true(env_var_name):
    """Whether the given environment variable has a truthy value."""
    return os.environ.get(env_var_name, "").lower().strip() in TRUE_STRINGS
def is_env_not_false(env_var_name):
    """Whether the given environment variable is empty or has a truthy value."""
    return os.environ.get(env_var_name, "").lower().strip() not in FALSE_STRINGS
def load_environment(profile: str = None):
    """Loads the environment variables from ~/.localstack/{profile}.env
    :param profile: the profile to load (defaults to "default")
    """
    if not profile:
        profile = "default"
    path = os.path.join(CONFIG_DIR, f"{profile}.env")
    if not os.path.exists(path):
        return
    import dotenv
    dotenv.load_dotenv(path, override=False)
def is_linux():