### Is there an existing issue for this?

- [X] I have searched the existing issues

### Feature description

LocalStack should support Server-Side-Encryption for SQS if possible, or at least pretend it does so that scripts that assume this working against AWS don't break with LocalStack.

Currently terraform for example fails when trying to create an SQS queue with `sqs_managed_sse_enabled     = true` 

### 🧑‍💻 Implementation

It would probably be fine for now to at least simulate this in a basic `CRUD` way for at least the case when using AWS managed keys for the "encryption".


Example terraform:

```hcl
provider "aws" { 
  access_key                  = "test"
  secret_key                  = "test"
  region                      = "us-east-1"
  s3_force_path_style         = true
  skip_credentials_validation = true
  skip_metadata_api_check     = true
  skip_requesting_account_id  = true

  endpoints {
    sqs            = "http://localhost:4566"
    iam            = "http://localhost:4566"
  }
}

resource "aws_sqs_queue" "sqs" {
  name                        = "myq.fifo"
  fifo_queue                  = true
  content_based_deduplication = true
  sqs_managed_sse_enabled     = true
  
  tags = {
    service     = "myq"
  }
}
```

### Anything else?

- https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-configure-sqs-sse-queue.html
- https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-server-side-encryption.html
self, context: RequestContext, queue_url: String, receipt_handle: String
    ) -> None:
        """Deletes the specified message from the specified queue. To select the
        message to delete, use the ``ReceiptHandle`` of the message (*not* the
        ``MessageId`` which you receive when you send the message). Amazon SQS
        can delete a message from a queue even if a visibility timeout setting
        causes the message to be locked by another consumer. Amazon SQS
        automatically deletes messages left in a queue longer than the retention
        period configured for the queue.
        The ``ReceiptHandle`` is associated with a *specific instance* of
        receiving a message. If you receive a message more than once, the
        ``ReceiptHandle`` is different each time you receive a message. When you
        use the ``DeleteMessage`` action, you must provide the most recently
        received ``ReceiptHandle`` for the message (otherwise, the request
        succeeds, but the message might not be deleted).
        For standard queues, it is possible to receive a message even after you
        delete it. This might happen on rare occasions if one of the servers
        which stores a copy of the message is unavailable when you send the
        request to delete the message. The copy remains on the server and might
        be returned to you during a subsequent receive request. You should
        ensure that your application is idempotent, so that receiving a message
        more than once does not cause issues.
        :param queue_url: The URL of the Amazon SQS queue from which messages are deleted.
        :param receipt_handle: The receipt handle associated with the message to delete.
        :raises InvalidIdFormat:
        :raises ReceiptHandleIsInvalid:
        """
        raise NotImplementedError
    @handler("DeleteMessageBatch")
    def delete_message_batch(