Make TryFrom<Element> chainable

This allows constructs like:

```rust
let residual = match Iq::try_from(stanza) {
  Ok(iq) => return handle_iq(..),
  Err(Error::TypeMismatch(_, _, v)) => v,
  Err(other) => return handle_parse_error(..),
};
let residual = match Message::try_from(stanza) {
  ..
};
let residual = ..
log::warn!("unhandled object: {:?}", residual);
```

The interesting part of this is that this could be used in a loop over a
Vec<Box<dyn FnMut(Element) -> ControlFlow<SomeResult, Element>>, i.e. in
a parsing loop for a generic XML/XMPP stream.

The advantage is that the stanza.is() check runs only once (in
check_self!) and doesn't need to be duplicated outside, and it reduces
the use of magic strings.

parsers/src/util/macros.rs

@@ -292,6 +292,21 @@ macro_rules! check_self {
     ($elem:ident, $name:tt, $ns:ident) => {
         check_self!($elem, $name, $ns, $name);
     };
+    ($elem:ident, $name:tt, $ns:ident, $pretty_name:tt) => {
+        if !$elem.is($name, crate::ns::$ns) {
+            return Err(crate::util::error::Error::TypeMismatch(
+                $name,
+                crate::ns::$ns,
+                $elem,
+            ));
+        }
+    };
+}
+
+macro_rules! check_child {
+    ($elem:ident, $name:tt, $ns:ident) => {
+        check_child!($elem, $name, $ns, $name);
+    };
     ($elem:ident, $name:tt, $ns:ident, $pretty_name:tt) => {
         if !$elem.is($name, crate::ns::$ns) {
             return Err(crate::util::error::Error::ParseError(concat!(