### Is there an existing issue for this?

- [X] I have searched the existing issues

### Feature description

SNS allows for the publishing of messages to an SMS destination with a phone number. Those messages are logged and stored in the `SnsStore`, but there is no way to retrieve them for verification. The request here is to expose a new endpoint which returns SMS messages from the store, similar to the one made available to retrieve email messages sent via SES.

### 🧑‍💻 Implementation

The `SNSServicePlatformEndpointMessagesApiResource` class makes endpoints available for accessing platform endpoint messages sent via SNS. A similar resource class could be implemented to provide new endpoints for accessing SMS messages.

Given that interaction platform endpoint messages is exposed at the path `/_aws/sns/platform-endpoint-messages`, SMS message interaction would presumably be exposed at `/_aws/sns/sms-messages`. A `GET` endpoint could accept an optional `phoneNumber` query parameter to filter messages based on the destination phone number.

```python
class SNSServiceSMSMessagesApiResource:
  @route(sns_constants.SMS_MSGS_ENDPOINT, methods=["GET"])
    def on_get(self, request: Request):
      account_id = #...
      region = #...
      filter_phone_number = request.args.get("phoneNumber")
      # get store; conditionally filter messages based on filter_phone_number
```

### Anything else?

_No response_
"""
    The EndpointPublisher is responsible for publishing SNS messages directly to an endpoint.
    SNS allows directly publishing to phone numbers and application endpoints.
    This is the base class implementing the basic logic.
    Each subclass will need to implement `_publish` and `prepare_message `using the subscription's protocol logic
    and client.
    """
    def publish(self, context: SnsPublishContext, endpoint: str):
        """
        This function wraps the underlying call to the actual publishing. This allows us to catch any uncaught
        exception and log it properly. This method is passed to the ThreadPoolExecutor, which would swallow the
        exception. This is a convenient way of doing it, but not something the abstract class should take care.
        Discussion here: https://github.com/localstack/localstack/pull/7267#discussion_r1056873437
        # TODO: move this out of the base class
        :param context: the SnsPublishContext created by the caller, containing the necessary data to publish the
        message
        :param endpoint: the endpoint where the message should be published
        :return:
        """
        try:
            self._publish(context=context, endpoint=endpoint)
        except Exception:
            LOG.exception(
                "An internal error occurred while trying to send the SNS message %s",
                context.message,
            )
            return
    def _publish(self, context: SnsPublishContext, endpoint: str):