Since Rust 1.84.0 the macro `CoercePointee` has
been made public on Nightly, so that it answers
the some usability questions.

If one wants to equip generic types with the
ability to weaken itself and to work with
unsized types with dynamic dispatching.
This feature is useful such that Rust code are
enabled to work with a family of types satisfying
the same protocol or Rust traits, while the same
safety guarantees are still uphold [1].
Examples of this weakening include those from
*[u8; 8]* to *[u8]*, eliding the concrete size of
the array; and a concrete type *T* to *dyn Trait*
where *T* implements the trait or traits *Trait*.

As of date, the exact language features to enable
this type weakening is still under stabilization
effort. Nevertheless, Alice Ryhl has proposed [2]
a very valuable combination of them such that a
user can enable this feature via a procedural
macro `CoercePointee` without much verbosity and
without declaring dependence on the relevant
unstable language features.

Alice has previously filed a patch [3] to
demonstrate the capability of this macro.
This patch provides further updates to incorporate
recent changes to the proposal in [2] and paves
the way for the final stabilization of the
feature in the Rust language.

A minimal demostration code is added to
the *samples/rust/rust_print_main.rs* module.

The use of the macro is now gated behind the
available Rust version *1.83.0*.
The *kernel* crate will still be as functional on
the prior Rust toolchains.

Link: https://doc.rust-lang.org/stable/nomicon/exotic-sizes.html?highlight=dynamic#dynamically-sized-types-dsts [1]
Link: https://rust-lang.github.io/rfcs/3621-derive-smart-pointer.html [2]
Link: https://lore.kernel.org/all/20240823-derive-smart-pointer-v1-1-53769cd37239@google.com/ [3]
Signed-off-by: Xiangfei Ding <dingxiangfei2009@protonmail.ch>