parsers: use Error type from xso

This is a large change and as such, it needs good motivation. Let me
remind you of the ultimate goal: we want a derive macro which allows us
to FromXml/IntoXml, and that derive macro should be usable from
`xmpp_parsers` and other crates.

For that, any code generated by the derive macro mustn't depend on any
code in the `xmpp_parsers` crate, because you cannot name the crate you
are in portably (`xmpp_parsers::..` wouldn't resolve within
`xmpp_parsers`, and `crate::..` would point at other crates if the macro
was used in other crates).

We also want to interoperate with code already implementing
`TryFrom<Element>` and `Into<Element>` on structs. This ultimately
requires that we have an error type which is shared by the two
implementations and that error type must be declared in the `xso` crate
to be usable by the macros.

Thus, we port the error type over to use the type declared in `xso`.

This changes the structure of the error type greatly; I do not think
that `xso` should have to know about all the different types we are
parsing there and they don't deserve special treatment. Wrapping them in
a `Box<dyn ..>` seems more appropriate.

xso/src/lib.rs

@@ -138,3 +138,38 @@ pub fn transform<T: FromXml, F: IntoXml>(from: F) -> Result<T, self::error::Erro
         rxml::error::XmlError::InvalidEof("during transform"),
     ))
 }
+
+/// Attempt to convert a [`minidom::Element`] into a type implementing
+/// [`FromXml`], fallably.
+///
+/// Unlike [`transform`] (which can also be used with an element), this
+/// function will return the element unharmed if its element header does not
+/// match the expectations of `T`.
+pub fn try_from_element<T: FromXml>(
+    from: minidom::Element,
+) -> Result<T, self::error::FromElementError> {
+    let (qname, attrs) = minidom_compat::make_start_ev_parts(&from)?;
+    let mut sink = match T::from_events(qname, attrs) {
+        Ok(v) => v,
+        Err(self::error::FromEventsError::Mismatch { .. }) => {
+            return Err(self::error::FromElementError::Mismatch(from))
+        }
+        Err(self::error::FromEventsError::Invalid(e)) => {
+            return Err(self::error::FromElementError::Invalid(e))
+        }
+    };
+
+    let mut iter = from.into_event_iter()?;
+    iter.next().expect("first event from minidom::Element")?;
+    for event in iter {
+        let event = event?;
+        match sink.feed(event)? {
+            Some(v) => return Ok(v),
+            None => (),
+        }
+    }
+    // unreachable! instead of error here, because minidom::Element always
+    // produces the complete event sequence of a single element, and FromXml
+    // implementations must be constructible from that.
+    unreachable!("minidom::Element did not produce enough events to complete element")
+}