xso: add traits for XML text <-> value conversion

The traits have undergone a couple iterations and this is what we end up
with. The core issue which makes this entire thing ugly is the
Orphan Rule, preventing some trait implementations relating to types
which haven't been defined in this crate.

In an ideal world, we would implement FromXmlText and IntoXmlText for
all types implementing FromStr and/or fmt::Display.

This comes with two severe issues:

1. Downstream crates cannot chose to have different
   parsing/serialisation behaviour for "normal" text vs. xml.

2. We ourselves cannot define a behaviour for `Option<T>`. `Option<T>`
   does not implement `FromStr` (nor `Display`), but the standard
   library *could* do that at some point, and thus Rust doesn't let us
   implement e.g. `FromXmlText for Option<T> where T: FromXmlText`,
   if we also implement it on `T: FromStr`.

The second one hurts particularly once we get to optional attributes:
For these, we need to "detect" that the type is in fact `Option<T>`,
because we then need to invoke `FromXmlText` on `T` instead of
`Option<T>`. Unfortunately, we cannot do that: macros operate on token
streams and we have no type information available.

We can of course match on the name `Option`, but that breaks down when
users re-import `Option` under a different name. Even just enumerating
all the possible correct ways of using `Option` from the standard
library (there are more than three) would be a nuisance at best.

Hence, we need *another* trait or at least a specialized implementation
of `FromXmlText for Option<T>`, and we cannot do that if we blanket-impl
`FromXmlText` on `T: FromStr`.

That makes the traits what they are, and introduces the requirement that
we know about any upstream crate which anyone might want to parse from
or to XML. This sucks a lot, but that's the state of the world. We are
late to the party, and we cannot expect everyone to do the same they
have done for `serde` (many crates have a `feature = "serde"` which then
provides Serialize/Deserialize trait impls for their types).

xso/src/text.rs

@@ -0,0 +1,105 @@
+// Copyright (c) 2024 Jonas Schäfer <jonas@zombofant.net>
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+//! Module containing implementations for conversions to/from XML text.
+
+use crate::{error::Error, FromXmlText, IntoXmlText};
+
+#[cfg(feature = "jid")]
+use jid;
+#[cfg(feature = "uuid")]
+use uuid;
+
+macro_rules! convert_via_fromstr_and_display {
+    ($($(#[cfg(feature = $feature:literal)])?$t:ty,)+) => {
+        $(
+            $(
+                #[cfg(feature = $feature)]
+                #[cfg_attr(docsrs, doc(cfg(feature = $feature)))]
+            )?
+            impl FromXmlText for $t {
+                fn from_xml_text(s: String) -> Result<Self, Error> {
+                    s.parse().map_err(Error::text_parse_error)
+                }
+            }
+
+            $(
+                #[cfg(feature = $feature)]
+                #[cfg_attr(docsrs, doc(cfg(feature = $feature)))]
+            )?
+            impl IntoXmlText for $t {
+                fn into_xml_text(self) -> Result<String, Error> {
+                    Ok(self.to_string())
+                }
+            }
+        )+
+    }
+}
+
+/// This provides an implementation compliant with xsd::bool.
+impl FromXmlText for bool {
+    fn from_xml_text(s: String) -> Result<Self, Error> {
+        match s.as_str() {
+            "1" => "true",
+            "0" => "false",
+            other => other,
+        }
+        .parse()
+        .map_err(Error::text_parse_error)
+    }
+}
+
+/// This provides an implementation compliant with xsd::bool.
+impl IntoXmlText for bool {
+    fn into_xml_text(self) -> Result<String, Error> {
+        Ok(self.to_string())
+    }
+}
+
+convert_via_fromstr_and_display! {
+    u8,
+    u16,
+    u32,
+    u64,
+    u128,
+    usize,
+    i8,
+    i16,
+    i32,
+    i64,
+    i128,
+    isize,
+    f32,
+    f64,
+    std::net::IpAddr,
+    std::net::Ipv4Addr,
+    std::net::Ipv6Addr,
+    std::net::SocketAddr,
+    std::net::SocketAddrV4,
+    std::net::SocketAddrV6,
+    std::num::NonZeroU8,
+    std::num::NonZeroU16,
+    std::num::NonZeroU32,
+    std::num::NonZeroU64,
+    std::num::NonZeroU128,
+    std::num::NonZeroUsize,
+    std::num::NonZeroI8,
+    std::num::NonZeroI16,
+    std::num::NonZeroI32,
+    std::num::NonZeroI64,
+    std::num::NonZeroI128,
+    std::num::NonZeroIsize,
+
+    #[cfg(feature = "uuid")]
+    uuid::Uuid,
+
+    #[cfg(feature = "jid")]
+    jid::Jid,
+    #[cfg(feature = "jid")]
+    jid::FullJid,
+    #[cfg(feature = "jid")]
+    jid::BareJid,
+}