### Is there an existing issue for this?

- [X] I have searched the existing issues

### Current Behavior

In AWS, DescribeSubnet Response returns:
```
<?xml version="1.0" encoding="UTF-8"?>\n
    <Response>
        <Errors>
            <Error>
                <Code>InvalidSubnetID.NotFound</Code>
                <Message>The subnet ID \'test\' does not exist</Message>
            </Error>
        </Errors>
    <RequestID>f6d041c1-1c96-4720-af30-77745504e2ba</RequestID>
</Response>
```

whereas localstack returns:
```
<?xml version=\'1.0\' encoding=\'utf-8\'?>\n<Errors xmlns="http://ec2.amazonaws.com/doc/2016-11-15">
    <Error>
        <Code>InvalidSubnetID.NotFound</Code>
        <Message>aaThe subnet ID \'vpc-test\' does not exist</Message>
    </Error>
    <RequestID>EADJHWMM796CI5FT10XGFMGOXIPCBAHBWINMV0HR6SKBRODGCU5J</RequestID>
</Errors>

```

### Expected Behavior

It should return correct response structure. It causes terraform to complain.

### How are you starting LocalStack?

Custom (please describe below)

### Steps To Reproduce

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

    make start

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

     awslocal ec2 describe-subnets --subnet-ids vpc-test --debug


### Environment

```markdown
- OS: M1 MacOS
- LocalStack: 1.0.2.dev
```


### Anything else?

Probably `call_moto` function in `localstack/services/moto.py` is changing the error code structure.
"""
Response serializers for the different AWS service protocols.
The module contains classes that take a service's response dict, and
given an operation model, serialize the HTTP response according to the
specified output shape.
It can be seen as the counterpart to the ``parse`` module in ``botocore``
(which parses the result of these serializer). It has a lot of
similarities with the ``serialize`` module in ``botocore``, but
serves a different purpose (serializing responses instead of requests).
The different protocols have many similarities. The class hierarchy is
designed such that the serializers share as much logic as possible.
The class hierarchy looks as follows:
::
                                      ┌───────────────────┐
                                      │ResponseSerializer │
                                      └───────────────────┘
                                          ▲    ▲      ▲
                   ┌──────────────────────┘    │      └──────────────────┐
      ┌────────────┴────────────┐ ┌────────────┴─────────────┐ ┌─────────┴────────────┐
      │BaseXMLResponseSerializer│ │BaseRestResponseSerializer│ │JSONResponseSerializer│
      └─────────────────────────┘ └──────────────────────────┘ └──────────────────────┘
                         ▲    ▲             ▲             ▲              ▲
  ┌──────────────────────┴─┐ ┌┴─────────────┴──────────┐ ┌┴──────────────┴──────────┐
  │QueryResponseSerializer │ │RestXMLResponseSerializer│ │RestJSONResponseSerializer│
  └────────────────────────┘ └─────────────────────────┘ └──────────────────────────┘
              ▲
   ┌──────────┴──────────┐