Nullable enum causes progenitor to generator both enum and newtype with same name

Let's say we have the following example spec:

{
    "openapi": "3.0.3",
    "info": {
        "title": "Example",
        "version": "0.0.1",
        "description": "Example",
        "contact": {
            "name": "Example",
            "url": "https://example.com"
        }
    },
    "components": {
        "schemas": {
            "ExampleEnum": {
                "type": "string",
                "nullable": true,
                "title": "ExampleEnum",
                "description": "An example enum",
                "enum": [
                    "test",
                    null
                ]
            }
        }
    },
    "paths": {}
}

When running progenitor using the binary, the following is generated:

pub mod types {
    use serde::{Deserialize, Serialize};
    #[doc = "An example enum"]
    #[derive(Serialize, Deserialize, Debug, Clone)]
    pub struct ExampleEnum(pub Option<ExampleEnum>);
    impl std::ops::Deref for ExampleEnum {
        type Target = Option<ExampleEnum>;
        fn deref(&self) -> &Self::Target {
            &self.0
        }
    }

    #[doc = "An example enum"]
    #[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash)]
    pub enum ExampleEnum {
        #[serde(rename = "test")]
        Test,
    }

    impl ToString for ExampleEnum {
        fn to_string(&self) -> String {
            match *self {
                ExampleEnum::Test => "test".to_string(),
            }
        }
    }
}

Notice that the newtype has the same name as the enum, conflicting with its implementation. I encountered this when working with the plaid open api spec, but I'm not sure if it's generally considered a valid case or not.

Start with the progenitor binary and the provided OpenAPI JSON spec, then inspect how the nullable ExampleEnum schema becomes the generated types module. Reproduce the duplicate Rust definitions and verify that the generated output no longer declares conflicting types with the same name and compiles successfully.