Suppress future incompatibility lint in CloneToAny impl

There's a new future incompatibility warning that recently started
firing on the code in CloneToAny (see [1]). It's triggering on code that
does a pointer cast from *mut dyn Trait to *mut dyn Trait + Send (or
other auto trait) which is an exact match for what this crate is doing.

The lint doesn't actually apply here though so it is safe to suppress
it. The recommended way to suppress it is to replace the pointer cast
with a transmute and that's what I have done here.

See the new safety comment for a more detailed explanation of why it is
safe.

[1]: rust-lang/rust#127323

Author: swlynch99

src/any.rs

@@ -34,7 +34,32 @@ macro_rules! impl_clone {
                 // ² https://github.com/rust-lang/rust/blob/e7825f2b690c9a0d21b6f6d84c404bb53b151b38/library/alloc/src/boxed.rs#L1613-L1616
                 let clone: Box<dyn CloneAny> = (**self).clone_to_any();
                 let raw: *mut dyn CloneAny = Box::into_raw(clone);
-                unsafe { Box::from_raw(raw as *mut $t) }
+
+                // SAFETY:
+                // There's a future incompat warning ptr_cast_add_auto_to_object tracked in [1]
+                // that warns when you use a pointer cast to add auto traits to a dyn Trait
+                // pointer.
+                //
+                // The issue that it is trying to avoid is that the trait may have methods that
+                // are conditional on the auto traits. e.g.
+                //
+                //    #![feature(arbitrary_self_types)]
+                //    trait Trait {
+                //        fn func(self: *const Self) where Self: Send;
+                //    }
+                //
+                // If this happens then the vtable for dyn Trait and the vtable for dyn Trait + Send
+                // may be different and so casting between pointers to each is UB.
+                //
+                // In our case we only care about the CloneAny trait. It has no methods that are
+                // conditional on any auto traits. This means that the vtable will always be the
+                // same and so the future incompatibility lint doesn't apply here.
+                //
+                // So, to avoid the lint, we use a transmute here instead of a pointer cast. As
+                // described in [1], that is the recommended way to suppress the warning.
+                //
+                // [1]: https://github.com/rust-lang/rust/issues/127323
+                unsafe { Box::from_raw(std::mem::transmute::<*mut dyn CloneAny, *mut _>(raw)) }
             }
         }