Support enum modelAsString

[johnbatty]

Add support for enum modelAsString attribute.

Fixes #768

If the modelAsString field in the spec is true, then generated enums have an additional UnknownValue(String) field that captures the string value if none of the other enum values match.

Simplified example:

    pub enum Status {
        Active,
        Inactive,
        UnknownValue(String),
    }

This cannot be done using standard serde attributes, so I have had to implement custom serializer/deserializers.

A more detailed example of the new code generated for the example given in the original issue:

pub mod hardware_profile {
    use super::*;
...
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    #[serde(remote = "VmSize")]
    pub enum VmSize {
        #[serde(rename = "Basic_A0")]
        BasicA0,
        #[serde(rename = "Basic_A1")]
        BasicA1,
        #[serde(rename = "Basic_A2")]
        BasicA2,
...
        #[serde(rename = "Standard_NV6")]
        StandardNv6,
        #[serde(rename = "Standard_NV12")]
        StandardNv12,
        #[serde(rename = "Standard_NV24")]
        StandardNv24,
        #[serde(skip_deserializing)]
        UnknownValue(String),
    }
    impl FromStr for VmSize {
        type Err = value::Error;
        fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
            Self::deserialize(s.into_deserializer())
        }
    }
    impl<'de> Deserialize<'de> for VmSize {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: Deserializer<'de>,
        {
            let s = String::deserialize(deserializer)?;
            let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
            Ok(deserialized)
        }
    }
    impl Serialize for VmSize {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            match self {
                Self::BasicA0 => serializer.serialize_unit_variant("VmSize", 0u32, "Basic_A0"),
                Self::BasicA1 => serializer.serialize_unit_variant("VmSize", 1u32, "Basic_A1"),
                Self::BasicA2 => serializer.serialize_unit_variant("VmSize", 2u32, "Basic_A2"),
...
                Self::StandardNv6 => serializer.serialize_unit_variant("VmSize", 163u32, "Standard_NV6"),
                Self::StandardNv12 => serializer.serialize_unit_variant("VmSize", 164u32, "Standard_NV12"),
                Self::StandardNv24 => serializer.serialize_unit_variant("VmSize", 165u32, "Standard_NV24"),
                Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
            }
        }
    }
}

[cataggar]

Awesome! I just confirmed that cargo run --package azure_mgmt_compute --example vm_list works for me with this change.