Allow `&'static AtomicBool` in flag module

[axelkar]

For an application, it's easier and more efficient to use static variables than Arcs. There's no heap allocation, no unnecessary atomic operations, etc.

I guess I could use something utilizing unsafe like this, but I digress.

// One heap allocation:
let flag = Arc::new(AtomicBool::new(false));
signal_hook::flag::register_conditional_shutdown(_, _, Arc::clone(flag))

// Leak it
let flag = unsafe { Arc::into_raw(flag) as &'static AtomicBool };

// Pass to `'static` code without using atomic operations

Maybe it could also support other smart pointers using generics? Like T: Borrow<AtomicBool> + 'static? There's even a blanket impl for &T to &T so my originally proposed use case works.

[vorner]

I don't think using the Arcs is a big deal - while you pay by the allocation once at the start of the application (you aren't registering the flags over and over again, are you?) and do some atomic operations, the actual use inside the signal handler should be rather cheap. AFAIK dereferencing an Arc should be cheap too. Also, signals (and this library) probably shouldn't be on the hot path anyway 😇

Anyway, loosening the restrictions a bit by the proposed generics makes sense (it should even be backwards compatible). I think there needs to be some kind of Send in there, but that's detail.

Will you send a PR implementing it?