Make temporary values useable in a fairly normal style through macros. This nicely wraps the hacks that work around
temporaries’ limitations. This crate is itself hopefully temporary, until Rust can natively solve the problem.

## What Problem does this Solve?

Normally `let str = &String::from("str");` shouldn’t compile. The inner `String` object should be dropped at the end of
the statement, leaving a dangling reference. However, in simple cases like this, Rust gives you a pass, by extending the
lifetime. Alas this has not yet been generalised. You can often work around that, by storing the temporary value in a
separate variable.

The same situation arises, when the temporary value is hidden. Only, then you have no influence to work around it. This
is famously the case with `format_args!`, the efficient alternative to heap-allocated `format!`. This strongly limits
its usefulness – or did, without these macros!

Returning a temporary value from a simple block also benefits from lifetime extension. Again this is not yet the case
for more complex blocks, like `if` or `match`. Since Rust doesn’t have a `? :` operator, that prevents dynamic choice
involving temporaries.  So, these fail to compile, showing both explicit and hidden temporaries in the 1<sup>st</sup>
case:

```compile_fail
// `x` & `y` would live longer than the `String` and `format_args`’ hidden temporary.
let x = &vec![&String::from("x")];
let y = format_args!("1 + 2 = {}", 1 + 2);

// Consuming the value directly in `print!()` would be ok, were it not for the man in the middle, `if`.
print!("{}", if 1 < 1 {
    format_args!("1 + 2 = {}", 1 + 2)
} else {
    format_args!("1 + 3 = {}", 1 + 3)
});
```

## The Solution

The `let` problem is solved by turning it into a `match`, making the value live as long as the following code. Multiple
choice is achieved by breaking from a tuple. Both of these are not nice to look at. Therefore `temporaries` wraps them
up in convenient macros.

This only applies to local processing. Returning a temporary value from a closure or function is alas not something a
macro can achieve. That requires a language change, such as `super let`, which is under discussion.

*This was inspired by [this](https://internals.rust-lang.org/t/format-args-with-long-lifetimes/19494/9) &
[this](https://github.com/rust-lang/rust/issues/92698). There is a similar crate, which, unlike this one, needs a
proc-macro, [`hoist_temporaries`](https://docs.rs/hoist_temporaries/latest/hoist_temporaries/).*