bevy_reflect: Update on_unimplemented attributes (#15110)

# Objective

Some of the new compile error messages are a little unclear (at least to
me). For example:

```
error[E0277]: `tests::foo::Bar` can not be created through reflection
   --> crates/bevy_reflect/src/lib.rs:679:18
    |
679 |         #[derive(Reflect)]
    |                  ^^^^^^^ the trait `from_reflect::FromReflect` is not implemented for `tests::foo::Bar`
    |
    = note: consider annotating `tests::foo::Bar` with `#[derive(Reflect)]` or `#[derive(FromReflect)]`
```

While the annotation makes it clear that `FromReflect` is missing, it's
not very clear from the main error message.

My IDE lists errors with only their message immediately present:

<p align="center">
<img width="700" alt="Image of said IDE listing errors with only their
message immediately present. These errors are as follows:
\"`tests::foo::Bar` can not be created through reflection\", \"The trait
bound `tests::foo::Bar: RegisterForReflection` is not satisfied\", and
\"The trait bound `tests::foo::Bar: type_info::MaybeTyped` is not
satisfied\""
src="https://github.com/user-attachments/assets/42c24051-9e8e-4555-8477-51a9407446aa">
</p>

This makes it hard to tell at a glance why my code isn't compiling.

## Solution

Updated all `on_unimplemented` attributes in `bevy_reflect` to mention
the relevant trait—either the actual trait or the one users actually
need to implement—as well as a small snippet of what not implementing
them means.

For example, failing to implement `TypePath` now mentions missing a
`TypePath` implementation. And failing to implement `DynamicTypePath`
now also mentions missing a `TypePath` implementation, since that's the
actual trait users need to implement (i.e. they shouldn't implement
`DynamicTypePath` directly).

Lastly, I also added some missing `on_unimplemented` attributes for
`MaybeTyped` and `RegisterForReflection` (which you can see in the image
above).

Here's how this looks in my IDE now:

<p align="center">
<img width="700" alt="Similar image as before showing the errors listed
by the IDE. This time the errors read as follows: \"`tests::foo::Bar`
does not implement `FromReflect` so cannot be reified through
reflection\", \"`tests::foo::Bar` does not implement
`GetTypeRegistration` so cannot be registered for reflection\", and
\"`tests::foo::Bar` does not implement `Typed` so cannot provide static
type information\""
src="https://github.com/user-attachments/assets/f6f8501f-0450-4f78-b84f-00e7a18d0533">
</p>


## Testing

You can test by adding the following code and verifying the compile
errors are correct:

```rust
#[derive(Reflect)]
struct Foo(Bar);

struct Bar;
```

crates/bevy_reflect/compile_fail/tests/reflect_derive/generics_fail.rs

@@ -12,8 +12,8 @@ struct NoReflect(f32);
 
 fn main() {
  let mut foo: Box<dyn Struct> = Box::new(Foo::<NoReflect> { a: NoReflect(42.0) });
- //~^ ERROR: `NoReflect` does not provide type registration information
- //~| ERROR: `NoReflect` can not provide type information through reflection
+ //~^ ERROR: `NoReflect` does not implement `GetTypeRegistration` so cannot provide type registration information
+ //~| ERROR: `NoReflect` does not implement `Typed` so cannot provide static type information
 
  // foo doesn't implement Reflect because NoReflect doesn't implement Reflect
  foo.get_field::<NoReflect>("a").unwrap();

crates/bevy_reflect/compile_fail/tests/reflect_remote/nested_fail.rs

@@ -25,7 +25,7 @@ mod incorrect_inner_type {
  //~^ ERROR: `TheirInner<T>` does not implement `PartialReflect` so cannot be introspected
  //~| ERROR: `TheirInner<T>` does not implement `PartialReflect` so cannot be introspected
  //~| ERROR: `TheirInner<T>` does not implement `PartialReflect` so cannot be introspected
- //~| ERROR: `TheirInner<T>` can not be used as a dynamic type path
+ //~| ERROR: `TheirInner<T>` does not implement `TypePath` so cannot provide dynamic type path information
  //~| ERROR: `?` operator has incompatible types
  struct MyOuter<T: FromReflect + GetTypeRegistration> {
  // Reason: Should not use `MyInner<T>` directly

crates/bevy_reflect/src/from_reflect.rs

@@ -22,8 +22,8 @@ use crate::{FromType, PartialReflect, Reflect};
 /// [`DynamicStruct`]: crate::DynamicStruct
 /// [crate-level documentation]: crate
 #[diagnostic::on_unimplemented(
- message = "`{Self}` can not be created through reflection",
- note = "consider annotating `{Self}` with `#[derive(FromReflect)]`"
+ message = "`{Self}` does not implement `FromReflect` so cannot be created through reflection",
+ note = "consider annotating `{Self}` with `#[derive(Reflect)]`"
 )]
 pub trait FromReflect: Reflect + Sized {
  /// Constructs a concrete instance of `Self` from a reflected value.

crates/bevy_reflect/src/lib.rs

@@ -620,6 +620,10 @@ pub mod __macro_exports {
  ///
  /// This trait has a blanket implementation for all types that implement `GetTypeRegistration`
  /// and manual implementations for all dynamic types (which simply do nothing).
+ #[diagnostic::on_unimplemented(
+ message = "`{Self}` does not implement `GetTypeRegistration` so cannot be registered for reflection",
+ note = "consider annotating `{Self}` with `#[derive(Reflect)]`"
+ )]
  pub trait RegisterForReflection {
  #[allow(unused_variables)]
  fn __register(registry: &mut TypeRegistry) {}

crates/bevy_reflect/src/path/mod.rs

@@ -237,7 +237,7 @@ impl<'a> ReflectPath<'a> for &'a str {
 /// [`Array`]: crate::Array
 /// [`Enum`]: crate::Enum
 #[diagnostic::on_unimplemented(
- message = "`{Self}` does not provide a reflection path",
+ message = "`{Self}` does not implement `GetPath` so cannot be accessed by reflection path",
  note = "consider annotating `{Self}` with `#[derive(Reflect)]`"
 )]
 pub trait GetPath: PartialReflect {

crates/bevy_reflect/src/type_info.rs

@@ -83,7 +83,7 @@ use thiserror::Error;
 ///
 /// [utility]: crate::utility
 #[diagnostic::on_unimplemented(
- message = "`{Self}` can not provide type information through reflection",
+ message = "`{Self}` does not implement `Typed` so cannot provide static type information",
  note = "consider annotating `{Self}` with `#[derive(Reflect)]`"
 )]
 pub trait Typed: Reflect + TypePath {
@@ -103,6 +103,10 @@ pub trait Typed: Reflect + TypePath {
 /// This trait has a blanket implementation for all types that implement `Typed`
 /// and manual implementations for all dynamic types (which simply return `None`).
 #[doc(hidden)]
+#[diagnostic::on_unimplemented(
+ message = "`{Self}` does not implement `Typed` so cannot provide static type information",
+ note = "consider annotating `{Self}` with `#[derive(Reflect)]`"
+)]
 pub trait MaybeTyped: PartialReflect {
  /// Returns the compile-time [info] for the underlying type, if it exists.
  ///

crates/bevy_reflect/src/type_path.rs

@@ -80,7 +80,7 @@ use std::fmt;
 /// [`module_path`]: TypePath::module_path
 /// [`type_ident`]: TypePath::type_ident
 #[diagnostic::on_unimplemented(
- message = "`{Self}` does not have a type path",
+ message = "`{Self}` does not implement `TypePath` so cannot provide static type path information",
  note = "consider annotating `{Self}` with `#[derive(Reflect)]` or `#[derive(TypePath)]`"
 )]
 pub trait TypePath: 'static {
@@ -134,7 +134,7 @@ pub trait TypePath: 'static {
 ///
 /// [`Reflect`]: crate::Reflect
 #[diagnostic::on_unimplemented(
- message = "`{Self}` can not be used as a dynamic type path",
+ message = "`{Self}` does not implement `TypePath` so cannot provide dynamic type path information",
  note = "consider annotating `{Self}` with `#[derive(Reflect)]` or `#[derive(TypePath)]`"
 )]
 pub trait DynamicTypePath {

crates/bevy_reflect/src/type_registry.rs

@@ -57,7 +57,7 @@ impl Debug for TypeRegistryArc {
 ///
 /// [crate-level documentation]: crate
 #[diagnostic::on_unimplemented(
- message = "`{Self}` does not provide type registration information",
+ message = "`{Self}` does not implement `GetTypeRegistration` so cannot provide type registration information",
  note = "consider annotating `{Self}` with `#[derive(Reflect)]`"
 )]
 pub trait GetTypeRegistration: 'static {