Emulate reborrowing for user types.
Given a &'a [mutable] reference of a &'b view over some owned object,
reborrowing it means getting an active &'a view over the owned object,
which renders the original reference inactive until it's dropped, at which point
the original reference becomes active again.
This fails to compile since we can't use a non-Copy value after it's moved.
```rust
fn takesmutoption(o: Option<&mut i32>) {}
let mut x = 0;
let o = Some(&mut x);
takesmutoption(o); // o is moved here,
takesmutoption(o); // so it can't be used here.
```
This can be worked around by unwrapping the option, reborrowing it, and then wrapping it again. ```rust fn takesmutoption(o: Option<&mut i32>) {}
let mut x = 0;
let mut o = Some(&mut x);
takesmutoption(o.asmut().map(|r| &mut **r)); // "Reborrowing" the Option
takesmutoption(o.asmut().map(|r| &mut **r)); // allows us to use it later on.
drop(o); // can still be used here
```
Using this crate, this can be shortened to ```rust use reborrow::ReborrowMut;
fn takesmutoption(o: Option<&mut i32>) {}
let mut x = 0;
let mut o = Some(&mut x);
takesmutoption(o.rbmut()); // "Reborrowing" the Option
takesmutoption(o.rbmut()); // allows us to use it later on.
drop(o); // can still be used here
```