Declare Signals that emit references

[LeonMatthesKDAB]

As of #281, Signals will be emitted immediately, which theoretically makes dealing with references much easier.

One can easily imagine an API like this:

#[cxx_qt::signals(MyObject)]
pub enum Signals<'x> {
    TestSignal { argument: &'x QVariant }
}

This however, doesn't work, even in #281.

error[E0261]: use of undeclared lifetime name `'x`
  --> examples/qml_features/rust/src/signals.rs:23:31
   |
7  | #[cxx_qt::bridge(cxx_file_stem = "signals")]
   |                                             -
   |                                             |
   |                                             lifetime `'x` is missing in item created through this procedural macro
   |                                             help: consider introducing lifetime `'x` here: `<'x>`
...
23 |         TestSignal { argument: &'x QVariant },
   |

This is caused by this generated code:

impl SignalsQt {
            pub fn emit_test_signal(
                self: ::std::pin::Pin<&mut Self>,
                argument: &'x QVariant,
            ) {
                extern "C" {
                    #[link_name = "cxxbridge1$Signals$emit_test_signal"]
                    fn __emit_test_signal(
                        _: ::std::pin::Pin<&mut SignalsQt>,
                        argument: *const ::cxx::core::ffi::c_void,
                    );
                }
                unsafe {
                    __emit_test_signal(
                        self,
                        argument as *const QVariant as *const ::cxx::core::ffi::c_void,
                    )
                }
            }
        }
}

The fix would be either to declare the 'x lifetime in emit_test_signal function in the CXX bridge.
Alternatively we could try removing the lifetime from the CXX Bridge, as that should be able to be deferred.

Furthermore, the emit function may cause problems, as it's defined as:

pub fn emit(self: Pin<&mut Self>, signal: Signal) {
                match signal {
                    Signal::TestSignal { argument } => self.emit_test_signal(emit),
                }
            }

But it may have to be defined as:

pub fn emit<'x>(self: Pin<&mut Self>, signal: Signal<'x>) {
                ...
            }