### Is there an existing issue for this?

- [X] I have searched the existing issues

### Current Behavior

if a Fifo queue is created withotu deduplication  configuration such as `MessageDeduplicationId` or `ContentBasedDeduplication`

Sending a batch of message to such queue will silently fail (with http code 200)

### Expected Behavior

it should fail with error

`InvalidParameterValue: The Queue should either have ContentBasedDeduplication enabled or MessageDeduplicationId provided explicitly `

### 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 127.0.0.1:4566:4566/tcp --network=host localstack/localstack:latest`

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

```js
const { SQSClient, SendMessageCommand, ReceiveMessageCommand, CreateQueueCommand, SendMessageBatchCommand }  = require('@aws-sdk/client-sqs')

const credentials = {
  accessKeyId: 'test',
  secretAccessKey: 'test',
};

const connection = {
  region: 'us-east-1',
  accountId: '000000000000',
  endpoint: 'http://localhost:4566',
};

const queueName = 'test-queue6.fifo';

async function main() {
  const sqsClient = new SQSClient({
    ...connection,
    credentials,
  });

  const { QueueUrl } = await sqsClient.send(new CreateQueueCommand({
    QueueName: queueName,
    Attributes: {
      FifoQueue: 'true',
      //ContentBasedDeduplication: 'true',
    }
  }));

  await sqsClient.send(new SendMessageBatchCommand({
    QueueUrl,
    Entries: [{
      Id: '1',
      MessageBody: 'test4',
      MessageGroupId: 'test-group'
    }]
  }));


  const { Messages } = await sqsClient.send(new ReceiveMessageCommand({
    QueueUrl
  }));

  return Messages
}

main().then((r) => console.log(r)).catch((e) => console.error(e));
```

### Environment

```markdown
- OS: Osx
- LocalStack:
```


### Anything else?

Use the lastest version on AWS SDK (!)
"""
        Returns the maxReceiveCount attribute of the redrive policy. If no redrive policy is set, then it
        returns None.
        """
        if redrive_policy := self.redrive_policy:
            return int(redrive_policy["maxReceiveCount"])
        return None
    @property
    def visibility_timeout(self) -> int:
        return int(self.attributes[QueueAttributeName.VisibilityTimeout])
    @property
    def delay_seconds(self) -> int:
        return int(self.attributes[QueueAttributeName.DelaySeconds])
    @property
    def wait_time_seconds(self) -> int:
        return int(self.attributes[QueueAttributeName.ReceiveMessageWaitTimeSeconds])
    @property
    def maximum_message_size(self) -> int:
        return int(self.attributes[QueueAttributeName.MaximumMessageSize])
    @property
    def approx_number_of_messages(self) -> int:
        raise NotImplementedError
    @property
    def approx_number_of_messages_not_visible(self) -> int:
        return len(self.inflight)
    @property
    def approx_number_of_messages_delayed(self) -> int: