[BUG] Can't specify requestBody is array of integers in OpenAPI Specification
<!--

/!\ IMPORTANT: Before opening issue

- Please update all of your packages. I won't investigate on the issue if you are on an old version.
- Please check that you have the same version for all Ts.ED dependencies (expected the logger). Many issues are related to a misconfigured packages.
- Please provide a reproducible example (avoid screenshot, prefer copy/pasted code). The stack trace isn't enough to investigate.

If theses requirements aren't checked, I WON'T INVESTIGATE (excepted if you are a PREMIUM SPONSORS!) and issue will be CLOSED!
-->

## Information

- **Version:** 7.3.0
- Packages: `@tsed/schema`

I have an endpoint that expects an array of integers in the request body. None of the decorators I've tried give the expected OpenAPI Specification.

## Example
I've tried the following approaches:

**A)** Using `@BodyParams() @Integer()`
```ts
import { BodyParams, Controller } from '@tsed/common';
import { Integer, Patch } from '@tsed/schema';

@Controller('/example')
export class ExampleController {
    @Patch('')
    async add(@BodyParams() @Integer() ids: number[]) {
        // ...
    }
}
```
results in:
```json
        "requestBody": {
          "required": false,
          "content": {
            "application/json": {
              "schema": {
                "type": "array",
                "items": {
                  "multipleOf": 1,
                  "nullable": true,
                  "oneOf": [
                    {
                      "type": "integer"
                    },
                    {
                      "type": "number"
                    },
                    {
                      "type": "string"
                    },
                    {
                      "type": "boolean"
                    },
                    {
                      "type": "array"
                    },
                    {
                      "type": "object"
                    }
                  ]
                }
              }
            }
          }
        },
```

**B)** Using `@BodyParams() @CollectionOf(Number) @Integer()`
```ts
import { BodyParams, Controller } from '@tsed/common';
import { CollectionOf, Integer, Patch } from '@tsed/schema';

@Controller('/example')
export class ExampleController {
    @Patch('')
    async add(@BodyParams() @CollectionOf(Number) @Integer() ids: number[]) {
        // ...
    }
}
```
results in
```json
        "requestBody": {
          "required": false,
          "content": {
            "application/json": {
              "schema": {
                "type": "array",
                "items": {
                  "type": "number",
                  "multipleOf": 1
                }
              }
            }
          }
        },
```

**C)** Using `@BodyParams() @Schema(array().integer())`
```ts
import { BodyParams, Controller } from '@tsed/common';
import { array, Patch, Schema } from '@tsed/schema';

@Controller('/example')
export class ExampleController {
    @Patch('')
    async add(@BodyParams() @Schema(array().integer()) ids: number[]) {
        // ...
    }
}
```
results in
```json
        "requestBody": {
          "required": false,
          "content": {
            "application/json": {
              "schema": {
                "type": "array",
                "items": {
                  "nullable": true,
                  "oneOf": [
                    {
                      "type": "integer"
                    },
                    {
                      "type": "number"
                    },
                    {
                      "type": "string"
                    },
                    {
                      "type": "boolean"
                    },
                    {
                      "type": "array"
                    },
                    {
                      "type": "object"
                    }
                  ]
                }
              }
            }
          }
        },
```

## Acceptance criteria
When it accepts an array of integers. I.e. when the `requestBody` looks like:
```json
        "requestBody": {
          "required": false,
          "content": {
            "application/json": {
              "schema": {
                "type": "array",
                "items": {
                  "type": "integer"
                }
              }
            }
          }
        },
```
