New lint against implicit coersion of pointers to types to pointers to trait objects

What it does

Catches when implicit coersion of the form Ptr<Type> -> Ptr<dyn Trait> happens, where Ptr is any pointer type.
Requires coersion to be performed via as operator.

Advantage

In dynamic world trait object may outlive its vtable if vtable is allocated in dynamic library segment and library is unloaded later.

Worse thing that it happens even if both type and trait come from another dylib dependency which stays loaded because vtables are not exported.
So author of unloadable library has to ensure that no vtables from that library can survive past the unload.

Making all vtable creation accompanied with as operator would help to find them and verify that they won't live longer than allowed.

Drawbacks

Should be disabled by default and not included in groups, probably even pedantic.
Hard to discover, the problem is not well known. I could only find one 4 years discussion rust-lang users forum.

Example

trait Foo {}
struct Bar;
impl Foo for Bar {}

fn use_foo(_: &mut dyn Foo) {}

fn make_foo() -> &'static dyn Foo {
  &Bar
}

let foo: Box<Foo> = Box::new(Bar);

use_foo(&mut Bar);

Could be written as:

trait Foo {}
struct Bar;
impl Foo for Bar {}

fn use_foo(_: &mut dyn Foo) {}

fn make_foo() -> &'static dyn Foo {
  &Bar as &dyn Foo
}

let foo: Box<dyn Foo> = Box::new(Bar) as Box<dyn Foo>;

use_foo(&mut Bar &mut dyn Foo);

Start from the proposed Rust examples and the stated pointer-to-trait-object coercion behavior. Define the lint's handling of all pointer types, ensure explicit as coercions are accepted, and verify that it is disabled by default and excluded from lint groups as requested.