repr: Remove unnecessary parse_uuid guard against a nonexistent uuid panic

`strconv::parse_uuid` (#36984) rejected inputs shorter than 32 chars or
non-ASCII before handing them to the `uuid` crate, on the premise that
`Uuid::parse_str` panics (rather than erroring) while building its parse error
for some malformed inputs by slicing on a non-char boundary. That premise is
false for the version we lock (uuid 1.19.0) and for every release back to
0.8.2: `Uuid::parse_str` returns a clean `Err` for all such inputs (`{}`,
`{\0}`, non-ASCII, etc.). `InvalidUuid::into_err` rejects non-UTF8 up front,
strips the `{}`/`urn:uuid:` wrappers on raw bytes (always standalone ASCII, so
char-safe), and its one subtraction can't underflow.

So the guard only suppressed the `uuid` crate's own (more detailed) error
message for short/non-ASCII input, and the `value_decode_text` regression test
asserted an invariant the crate already upholds. No saved cargo-fuzz artifact
reaches a uuid panic. Restore the original parser and drop the vacuous test.
Mirrors removing the equivalent persist `parse_id`/`ShardId::from_str` guard.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: def-

src/repr/src/strconv.rs

@@ -731,15 +731,7 @@ where
 }
 
 pub fn parse_uuid(s: &str) -> Result<Uuid, ParseError> {
-    let trimmed = s.trim();
-    // The `uuid` crate panics while constructing a parse error for some short,
-    // brace-wrapped inputs (e.g. `{}`, `{\0}`) because it mis-slices the input.
-    // Reject anything that can't be a UUID before handing it to the crate. The
-    // shortest valid form is 32 hex digits and every form is ASCII.
-    if trimmed.len() < 32 || !trimmed.is_ascii() {
-        return Err(ParseError::invalid_input_syntax("uuid", s));
-    }
-    trimmed
+    s.trim()
         .parse()
         .map_err(|e| ParseError::invalid_input_syntax("uuid", s).with_details(e))
 }
@@ -2206,19 +2198,4 @@ mod tests {
         let s = format!("{}{}", "x".repeat(62), "א");
         assert_eq!("x".repeat(62), parse_pg_legacy_name(&s));
     }
-
-    #[mz_ore::test]
-    fn test_parse_uuid_rejects_non_uuid_input() {
-        // The `uuid` crate panics while constructing a parse error for some
-        // short, brace-wrapped inputs (e.g. `{}`, `{\0}`). `parse_uuid` must
-        // reject anything that can't be a UUID as an error, never panic.
-        // Regression for the value_decode_text cargo-fuzz finding.
-        for s in ["", "{}", "{\0}", "{", "}", "xyz", "{ }", "\u{0}\u{0}\u{0}"] {
-            assert!(parse_uuid(s).is_err(), "parse_uuid({s:?}) should be Err");
-        }
-        // Valid UUIDs (and their accepted forms) still parse.
-        assert!(parse_uuid("00000000-0000-0000-0000-000000000000").is_ok());
-        assert!(parse_uuid("{00000000-0000-0000-0000-000000000000}").is_ok());
-        assert!(parse_uuid("00000000000000000000000000000000").is_ok());
-    }
 }

src/storage-types/src/sources/casts.rs

@@ -818,13 +818,13 @@ mod tests {
 
         #[mz_ore::test]
         fn error_uuid() {
-            // `parse_uuid` rejects anything too short to be a UUID before the
-            // `uuid` crate runs (the crate panics building an error for some
-            // short inputs), so the error carries no crate-specific detail.
-            // This matches Postgres, whose message for `'bad'::uuid` has none.
             assert_eq!(
                 eval_cast_err(CastFunc::CastStringToUuid, "bad"),
-                parse_err("uuid", "bad"),
+                parse_err_with_details(
+                    "uuid",
+                    "bad",
+                    "invalid length: expected length 32 for simple format, found 3"
+                ),
             );
         }