The exception object can be passed as a pointer via `CxxException`
error through Rust frames.

A method to create the default message-based `rust::Error` and to drop
and clone the exception are provided.

This represents C++ `std::exception_ptr` on the Rust side via
`CxxException` object, which can be mentioned as a return type for
functions creating custom exceptions or evaluating exceptions caught
from C++ (added in further commits).

This makes the interface between C++ exception handling and Rust
`Result` cleaner and allows passing C++ exception from the inner C++
call to the outer C++ call via Rust's `CxxException` unmodified, i.e.,
without losing information.

To allow custom exception types, trait `ToCxxException` was introduced.
With this trait, it's possible to convert a Rust error to the wrapper
`CxxExeception` via a C++ function, thus allowing throwing other
exceptions as well. This required changing `r#try` function into
macros, so we can properly default to `rust::Error` for errors not
having `ToCxxException` defined.

Background: The `throw` statement in C++ (__cxa_throw) effectively
first allocates space on the heap and creates the exception within,
then starts unwinding. This can be also done via standard C++11 API in
two steps. First, `std::make_exception_ptr()` creates a new
`std::exception_ptr`, which points into this allocated space and
internally is just a pointer (it's a smart pointer much like
`std::shared_ptr`). Then, `std::rethrow_exception()` can be used to
actually throw and/or rethrow this exception.

Basically, the new implementation now uses `std::make_exception_ptr()`
called from Rust to construct an exception for the `Result<_, E>` and
then after returning it back to C++ via `CxxResult` (which is now BTW
smaller, just 8B) the C++ part throws it using
`std::rethrow_exception()`.

Since invalid `Result<T>` output changed, the expected file had to be
updated.

The output actually got better, since now the location of the actual
declaration of the offending struct is also shown, not only the usage.

Contrary to the most platforms, which just store a single pointer in
`std::exception_ptr`, MSVC stores two. Add necessary code to handle
this.

Previously, modifying tests.h/cc would not trigger rebuild of the
bridge, effectively preventing test development.

C++ error message returned by `what` must be NUL-terminated. However,
the current copy function only copied the characters, but didn't add
the NUL. Allocate one more byte and set it to NUL.

…ate.

The normalization in `trybuild` crate doesn't work in the CI (but works
fine locally).

Instead, expand the match directly in `expand.rs` to minimize the
public API.