Type name collision fix

[SRetip]

Problem:
If we try to generate schema from this schema:

{
    "$schema": "http:https://json-schema.org/draft-04/schema#",
    "definitions": {
        "Foo": {
            "properties": {
                "Bar": {
                    "oneOf": [
                        {
                            "$ref": "#/definitions/FooBar"
                        },
                        {
                            "$ref": "#/definitions/Baz"
                        }
                    ]
                }
            },
            "type": "object"
        },
        "FooBar": {
            "type": "string"
        },
        "Baz": {
            "type": "string"
        }
    }
}

we get:

pub struct Baz(pub String);

pub struct Foo {
    pub bar: Option<FooBar>,
}

pub struct FooBar(pub String);

pub enum FooBar {
    FooBar(FooBar),
    Baz(Baz),
}

where struct FooBar - structure from definition:

  "FooBar": {
            "type": "string"
        },

and enum FooBar - enum which come from property definition:

 "Bar": {
                    "oneOf": [
                        {
                            "$ref": "#/definitions/FooBar"
                        },
                        {
                            "$ref": "#/definitions/Baz"
                        }
                    ]
                }

and as a result, we have a name conflict.

With my solution result will be:

pub struct Baz(pub String);

pub struct Foo {
    pub bar: Option<FooBarAlias>,
}

pub struct FooBar(pub String);

pub enum FooBarAlias {
    FooBar(FooBar),
    Baz(Baz),
}

I'd be happy to have a feedback :)

[ahl]

I appreciate that this solves for the case you have in mind, but the solution seems fairly narrow. For example, it applies to add_ref_types, but not to add_type. I'm concerned that successively suffixing "Alias" isn't going to produce types that are particularly usable.

Comments describing your approach would be helpful. Its placement was a little confusing. For example, we're doing this during the type finalization pass... but I'm not sure this has anything to do with type finalization.

[SRetip]

If I understand you correctly, I have corrected what was required:

• put this logic in a separate method for TypeEntry;
• added the call of this function to the TypeSpace::add_type_with_name(...) method;
• added comments:

// I think we should do it this way, because in this place we're iterating over all 
// created types.

As for adding "Alias", I honestly can't think of a way to make it more user friendly. But otherwise the code will simply not compile without this.

P.S. The "Alias" post-fix is generated only when there is a name conflict.