Attributes with same name as type cause name conflicts

Start by reproducing the issue with the Python Pydantic schema and inspect the code-generation path that produces the shown Rust types. Trace how names are assigned to the generated struct and enum, then add regression coverage for this schema. Done means the generated Rust no longer declares conflicting types and remains valid.

Sample JSON schema:

{
    "$defs": {
      "FirstType": {
        "properties": {
          "first": {
            "title": "First",
            "type": "string"
          }
        },
        "required": [
          "first"
        ],
        "title": "FirstType",
        "type": "object"
      },
      "SecondType": {
        "properties": {
          "second": {
            "title": "Second",
            "type": "string"
          }
        },
        "required": [
          "second"
        ],
        "title": "SecondType",
        "type": "object"
      }
    },
    "properties": {
      "test": {
        "anyOf": [
          {
            "$ref": "#/$defs/FirstType"
          },
          {
            "$ref": "#/$defs/SecondType"
          },
          {
            "type": "null"
          }
        ],
        "title": "Test"
      }
    },
    "required": [
      "test"
    ],
    "title": "Test",
    "type": "object"
  }

This is the JSON schema of this simple class structure (sample code in Python):

import json
from pydantic import BaseModel

class FirstType(BaseModel):
    first: str

class SecondType(BaseModel):
    second: str

class Test(BaseModel):
    test: FirstType | SecondType | None

test_json = Test.model_json_schema()

print(json.dumps(test_json, indent=2))

This results in the following generated schema from using typify. I have only included the important parts:

pub struct Test {
    pub test: Test,
}
impl ::std::convert::From<&Test> for Test {
    fn from(value: &Test) -> Self {
        value.clone()
    }
}
impl Test {
    pub fn builder() -> builder::Test {
        Default::default()
    }
}
pub enum Test {
    Variant0(FirstType),
    Variant1(SecondType),
    Variant2,
}
impl ::std::convert::From<&Self> for Test {
    fn from(value: &Test) -> Self {
        value.clone()
    }
}
impl ::std::convert::From<FirstType> for Test {
    fn from(value: FirstType) -> Self {
        Self::Variant0(value)
    }
}
impl ::std::convert::From<SecondType> for Test {
    fn from(value: SecondType) -> Self {
        Self::Variant1(value)
    }
}

Obviously, you can't have an enum and a struct with the same name (enum Test and struct Test).