[FEAT] Add discriminator support for describing schema and mapping object
## Information

Swagger provide a way to use OneOf feature with a discriminator property. See: https://swagger.io/docs/specification/data-models/inheritance-and-polymorphism/

**Is your feature request related to a problem? Please describe.**

The problem around the OneOf decorator usage is when the decorator is used with BodyParams/QueryParams, the json-mapper is not really able to retrieve the expected type. Here is an example:

```typescript
@Post("/")
  async addEvents(
    @BodyParams()
    @OneOf(
      EventA,
      EventB,
      EventC,
    )
    events: EventType[]
  ) {
    // validation works!
    for (let i = 0; i < events.length; i++) {
      $log.info(events[i].constructor.name); // is Object and not instance of class
    }
  }
```

In this example, there is no information for the json-mapper on the way to map the json object to a class instance.

**Describe the solution you'd like**

### JsonSchema

The discriminator can help the json-mapper to map correctly the json object to a class instance.

```ts
import {Discriminator, DiscriminatorKey, DiscriminatorValue, Property, Required, OneOf} from "@tsed/schema";

export class Event {
  @DiscriminatorKey() // declare this property a discriminator key
  type: string;

  @Property()
  value: string;
}

@DiscriminatorValue("page_view") // or @DiscriminatorValue() value can be inferred by the class name
export class PageView  extends Event {
 @Required()
  url: string;
}

@DiscriminatorValue("action")
export class Action  extends Event {
 @Required()
  event: string;
}

export class Tracking {
   @OneOf(Action, PageView)
   data: Action | PageView;
}
```

```ts
const schema = getJsonSchema(Tracking)
```

The following example should generate the following swagger-schema:


```jsonc
{
   "type": "object",
   "properties": {
       "data": {
         "discriminator": {
           "propertyName": "type"
         },
        "required": ["type"],
        "oneOf": [
            {"$ref": "#/definitions/Action"},
            {"$ref": "#/definitions/PageView"}
         ]
      }
   },
   "definitions": {
      "PageView": {},
      "Action": {}
   }
}
```

### Usage on endpoint

```typescript
@Controller("/events")
export class EventsController {
  @Post("/")
  @Returns(200, Array).OneOf(EventA, EventB, EventC)
  async addEvents(@BodyParams() @OneOf(EventA, EventB, EventC) events: EventType[]) {

    return events
  }
}
```

A sugar syntax can be used to avoid the list of different type of event:

```typescript
@Controller("/events")
export class EventsController {
  @Post("/")
  @Returns(200, Array).OneOf(EventType) // is Equivalent to .OneOf(EventA, EventB, EventC)
  async addEvents(@BodyParams() @OneOf(EventType) events: EventType[]) {
    return events;
  }
}
```
In this case, Ts.ED will infer all classes related to the same parent class. Add new children class won't require to update all endpoint/model that consume the base class.

### Mongoose

The module `@tsed/mongoose` has a `@DiscriminatorKey()`. `@tsed/schema` will implement directly this decorator. `@tsed/mongoose` must reexport this decorator and consume metadata from `@tsed/schema` instead.


```ts
import {Required} from "@tsed/schema";
import {Model, ObjectID, DiscriminatorKey} from "@tsed/mongoose";

@Model()
class EventModel {
  @ObjectID()
  _id: string;

  @Required()
  time: Date = new Date();

  @DiscriminatorKey()
  type: string;
}

@Model()
class ClickedLinkEventModel extends EventModel {
  @Required()
  url: string;
}

@Model({discriminatorValue: "signUpEvent"}) // must call @DescriminatorValue() underthehood
class SignedUpEventModel extends EventModel {
  @Required()
  user: string;
}

```
## Acceptance criteria

- [ ] AJV validate the given schema
- [ ] @tsed/json-mapper resolve correctly the model type according to the declared discriminator key
- [ ] The server return the correct json object based on the returned model.
- [ ] Mongoose use discriminator from `@tsed/schema`

