feat(templated_uri): add TryFrom<&str> for PathAndQuery (#464)

## Summary

Re-adds a `TryFrom<&str>` implementation for
`templated_uri::PathAndQuery` that was lost during prior refactorings,
restoring parity with `http::uri::PathAndQuery` and giving callers a
natural way to build a `PathAndQuery` from runtime string data.

`
ust
let pq = PathAndQuery::try_from("/api/v1/users?active=true")?;
`

## Behavior

- Delegates to `http::uri::PathAndQuery::try_from` and wraps the result
via the existing `From<HttpPathAndQuery> for PathAndQuery` impl.
- Errors propagate through `?` as `UriError` via the existing
`From<InvalidUri> for UriError` impl (label: `uri_invalid`). No extra
allocation, source is preserved on `Error::source()`.
- Inputs without a leading `/` are rejected. This is enforced by the
upstream `http` parser, which behaves identically across its entry
points (`try_from` returns `InvalidUri`; `from_static` panics with
*"static str is not valid path"*), so no duplicate check is added here.

## Tests

Three new unit tests in `crates/templated_uri/src/path_and_query.rs`:

- `try_from_str_succeeds` — happy path with query string.
- `try_from_str_invalid_errors` — invalid character (`/invalid path\0`)
returns `UriError` with label `uri_invalid`.
- `try_from_str_without_leading_slash_errors` — slash-less input returns
`UriError` with label `uri_invalid`.

## Not included

- No `TryFrom<&[u8]>` variant. The upstream `http` crate offers it to
let byte-oriented network code skip a UTF-8 check, but `PathAndQuery` at
this layer is composed from string templates, `&'static str`, and
`Sensitive<String>` — no concrete byte-slice caller exists. Trivial to
add later if one appears.
- No manual `CHANGELOG.md` entry — handled at release time by
`scripts/release-crate.ps1`.

---------

Co-authored-by: Kateřina Churanová <katerina.churanova@microsoft.com>
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: 3 people

crates/templated_uri/src/path_and_query.rs

@@ -137,6 +137,40 @@ impl From<HttpPathAndQuery> for PathAndQuery {
     }
 }
 
+impl TryFrom<&str> for PathAndQuery {
+    type Error = UriError;
+
+    /// Parses a string into a [`PathAndQuery`].
+    ///
+    /// The input must start with `/` (per RFC 3986 `path-abempty`); inputs without a
+    /// leading slash are rejected to avoid inconsistent rendering downstream.
+    ///
+    /// # Errors
+    ///
+    /// Returns a [`UriError`] if the string does not start with `/` or is not a valid
+    /// path-and-query.
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        Ok(Self::from(HttpPathAndQuery::try_from(value)?))
+    }
+}
+
+impl TryFrom<String> for PathAndQuery {
+    type Error = UriError;
+
+    /// Parses an owned string into a [`PathAndQuery`], reusing its buffer.
+    ///
+    /// Prefer this over the `&str` overload when the string is already owned: the
+    /// underlying [`http::uri::PathAndQuery`] takes the buffer without copying.
+    ///
+    /// # Errors
+    ///
+    /// Returns a [`UriError`] if the string does not start with `/` or is not a valid
+    /// path-and-query.
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        Ok(Self::from(HttpPathAndQuery::try_from(value)?))
+    }
+}
+
 impl TryFrom<&PathAndQuery> for HttpPathAndQuery {
     type Error = UriError;
 
@@ -220,4 +254,37 @@ mod tests {
         let converted_ref: HttpPathAndQuery = HttpPathAndQuery::try_from(&target_path).unwrap();
         assert_eq!(converted, converted_ref);
     }
+
+    #[test]
+    fn try_from_str_succeeds() {
+        let target_path = PathAndQuery::try_from("/api/v1/users?active=true").unwrap();
+        assert_eq!(target_path.to_string().declassify_ref(), "/api/v1/users?active=true");
+    }
+
+    #[test]
+    fn try_from_str_invalid_errors() {
+        use ohno::Labeled;
+        let err = PathAndQuery::try_from("/invalid path\0").unwrap_err();
+        assert_eq!(err.label(), "uri_invalid");
+    }
+
+    #[test]
+    fn try_from_str_without_leading_slash_errors() {
+        use ohno::Labeled;
+        let err = PathAndQuery::try_from("api/v1/users").unwrap_err();
+        assert_eq!(err.label(), "uri_invalid");
+    }
+
+    #[test]
+    fn try_from_string_succeeds() {
+        let target_path = PathAndQuery::try_from(String::from("/api/v1/users?active=true")).unwrap();
+        assert_eq!(target_path.to_string().declassify_ref(), "/api/v1/users?active=true");
+    }
+
+    #[test]
+    fn try_from_string_invalid_errors() {
+        use ohno::Labeled;
+        let err = PathAndQuery::try_from(String::from("api/v1/users")).unwrap_err();
+        assert_eq!(err.label(), "uri_invalid");
+    }
 }