TypeData dependencies (#22016)

# Objective

The proposed ["Resources as
entities"](#20934 ) PR makes
Resource implement Component. This creates a situation where we need to
do:

```rust
#[derive(Resource, Reflect)]
#[reflect(Resource, Component)]
struct Thing;
```

I'm of the mind that we should add the ability for TypeData to have
"dependencies". Ex `reflect(Resource)` implies `reflect(Component)`. For
"subtrait" types, I think supporting this is logical / users would
appreciate it.

## Solution

1. Add a new `FromType<T>::insert_dependencies` function with a default
impl (which makes this a non-breaking change). This does kind of
overload the `FromType` trait (ex: a name like `GetTypeData` might be
better with this new context), but this is a pretty niche trait / piece
of functionality, and I like the idea of not breaking people.
2. Add a new `TypeRegistration::register_type_data<T, V>` function,
which initializes the TypeData `T` for a given type `V` , inserts that
type data, and also inserts any dependent type data using
`insert_dependencies`.
3. Adjust the `Reflect` macro to use `register_type_data` instead of
`insert(FromType::<Self>::from_type())`

This makes it possible to do the following:

```rust
impl<R: Resource + FromReflect + TypePath> FromType<R> for ReflectResource {
    fn from_type() -> Self {
        ReflectResource
    }

    fn insert_dependencies(type_registration: &mut TypeRegistration) {
        type_registration.register_type_data::<ReflectComponent, R>();
    }
}
```

Which then allows dropping `reflect(Component)`:

```rust
#[derive(Resource, Reflect)]
#[reflect(Resource)]
struct Thing;
```

## Testing

I added a unit test 😜

Author: cart

crates/bevy_reflect/derive/src/registration.rs

@@ -49,7 +49,7 @@ pub(crate) fn impl_get_type_registration<'a>(
                 registration.insert::<#bevy_reflect_path::ReflectFromPtr>(#bevy_reflect_path::FromType::<Self>::from_type());
                 #from_reflect_data
                 #serialization_data
-                #(registration.insert::<#registration_data>(#bevy_reflect_path::FromType::<Self>::from_type());)*
+                #(registration.register_type_data::<#registration_data, Self>();)*
                 registration
             }
 

crates/bevy_reflect/src/lib.rs

@@ -3606,6 +3606,36 @@ bevy_reflect::tests::Test {
             assert!(registry.contains(TypeId::of::<OpaqueStructReflect>()));
             assert!(registry.contains(TypeId::of::<ZSTOpaqueStructReflect>()));
         }
+
+        #[test]
+        fn type_data_dependency() {
+            #[derive(Reflect)]
+            #[reflect(A)]
+            struct X;
+
+            #[derive(Clone)]
+            struct ReflectA;
+
+            impl<T> FromType<T> for ReflectA {
+                fn from_type() -> Self {
+                    ReflectA
+                }
+
+                fn insert_dependencies(type_registration: &mut TypeRegistration) {
+                    type_registration.insert(ReflectB);
+                }
+            }
+
+            #[derive(Clone)]
+            struct ReflectB;
+
+            let mut registry = TypeRegistry::new();
+            registry.register::<X>();
+
+            let registration = registry.get(TypeId::of::<X>()).unwrap();
+            assert!(registration.data::<ReflectA>().is_some());
+            assert!(registration.data::<ReflectB>().is_some());
+        }
     }
 
     #[cfg(feature = "glam")]

crates/bevy_reflect/src/type_registry.rs

@@ -588,6 +588,13 @@ impl TypeRegistration {
         self.data.insert(TypeId::of::<T>(), Box::new(data));
     }
 
+    /// Inserts the [`TypeData`] instance of `T` created for `V`, and inserts any
+    /// [`TypeData`] dependencies for that combination of `T` and `V`.
+    pub fn register_type_data<T: TypeData + FromType<V>, V>(&mut self) {
+        self.insert(T::from_type());
+        T::insert_dependencies(self);
+    }
+
     /// Returns a reference to the value of type `T` in this registration's
     /// [type data].
     ///
@@ -747,6 +754,10 @@ where
 pub trait FromType<T> {
     /// Creates an instance of `Self` for type `T`.
     fn from_type() -> Self;
+    /// Inserts [`TypeData`] dependencies of this [`TypeData`].
+    /// This is especially useful for trait [`TypeData`] that has a supertrait (ex: `A: B`).
+    /// When the [`TypeData`] for `A` is inserted, the `B` [`TypeData`] will also be inserted.
+    fn insert_dependencies(_type_registration: &mut TypeRegistration) {}
 }
 
 /// A struct used to serialize reflected instances of a type.