Enforce constraints for unnamed enums (#3884)

### Enforces Constraints for Unnamed Enums

This PR addresses the issue where, on the server side, unnamed enums
were incorrectly treated as infallible during deserialization, allowing
any string value to be converted without validation. The solution
introduces a `ConstraintViolation` and `TryFrom` implementation for
unnamed enums, ensuring that deserialized values conform to the enum
variants defined in the Smithy model.

The following is an example of an unnamed enum:

```smithy
@enum([
    { value: "MONDAY" },
    { value: "TUESDAY" }
])
string UnnamedDayOfWeek
```

On the server side the following type is generated for the Smithy shape:

```rust
pub struct UnnamedDayOfWeek(String);

impl ::std::convert::TryFrom<::std::string::String> for UnnamedDayOfWeek {
    type Error = crate::model::unnamed_day_of_week::ConstraintViolation;

    fn try_from(
        s: ::std::string::String,
    ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<::std::string::String>>::Error>
    {
        match s.as_str() {
            "MONDAY" | "TUESDAY" => Ok(Self(s)),
            _ => Err(crate::model::unnamed_day_of_week::ConstraintViolation(s)),
        }
    }
}
```

This change prevents invalid values from being deserialized into unnamed
enums and raises appropriate constraint violations when necessary.

There is one difference between the Rust code generated for
`TryFrom<String>` for named enums versus unnamed enums. The
implementation for unnamed enums passes the ownership of the `String`
parameter to the generated structure, and the implementation for
`TryFrom<&str>` delegates to `TryFrom<String>`.

```rust
impl ::std::convert::TryFrom<::std::string::String> for UnnamedDayOfWeek {
    type Error = crate::model::unnamed_day_of_week::ConstraintViolation;
    fn try_from(
        s: ::std::string::String,
    ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<::std::string::String>>::Error>
    {
        match s.as_str() {
            "MONDAY" | "TUESDAY" => Ok(Self(s)),
            _ => Err(crate::model::unnamed_day_of_week::ConstraintViolation(s)),
        }
    }
}

impl ::std::convert::TryFrom<&str> for UnnamedDayOfWeek {
    type Error = crate::model::unnamed_day_of_week::ConstraintViolation;
    fn try_from(
        s: &str,
    ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<&str>>::Error> {
        s.to_owned().try_into()
    }
}
```

On the client side, the behaviour is unchanged, and the client does not
validate for backward compatibility reasons. An [existing
test](https://github.com/smithy-lang/smithy-rs/pull/3884/files#diff-021ec60146cfe231105d21a7389f2dffcd546595964fbb3f0684ebf068325e48R82

)
has been modified to ensure this.

```rust
#[test]
fn generate_unnamed_enums() {
    let result = "t2.nano"
        .parse::<crate::types::UnnamedEnum>()
        .expect("static value validated to member");
    assert_eq!(result, UnnamedEnum("t2.nano".to_owned()));
    let result = "not-a-valid-variant"
        .parse::<crate::types::UnnamedEnum>()
        .expect("static value validated to member");
    assert_eq!(result, UnnamedEnum("not-a-valid-variant".to_owned()));
}
```

Fixes issue #3880

---------

Co-authored-by: Fahad Zubair <fahadzub@amazon.com>