Allow registering of resources via ReflectResource / ReflectComponent (#15496)

# Objective

- Resolves #15453
## Solution

- Added new `World::resource_id` and `World::register_resource` methods
to support this feature
- Added new `ReflectResource::register_resource` method, and new pointer
to this new function
- Added new `ReflectComponent::register_component`

## Testing

- Tested this locally, but couldn't test the entire crate locally, just
this new feature, expect that CI will do the rest of the work.

---

## Showcase


```rs
#[derive(Component, Reflect)]
#[reflect(Component)]
struct MyComp;

let mut world = World::new();
let mut registry = TypeRegistration::of::<MyComp>();
registry.insert::<ReflectComponent>(FromType::<MyComp>::from_type());
let data = registry.data::<ReflectComponent>().unwrap();

// Its now possible to register the Component in the world this way
let component_id = data.register_component(&mut world);

// They will be the same
assert_eq!(component_id, world.component_id::<MyComp>().unwrap());
```

```rs
#[derive(Resource, Reflect)]
#[reflect(Resource)]
struct MyResource;

let mut world = World::new();
let mut registry = TypeRegistration::of::<MyResource>();
registry.insert::<ReflectResource>(FromType::<MyResource>::from_type());
let data = registry.data::<ReflectResource>().unwrap();

// Same with resources
let component_id = data.register_resource(&mut world);

// They match
assert_eq!(component_id, world.resource_id::<MyResource>().unwrap());
```

crates/bevy_ecs/src/reflect/component.rs

@@ -60,7 +60,7 @@
 use super::from_reflect_with_fallback;
 use crate::{
     change_detection::Mut,
-    component::Component,
+    component::{Component, ComponentId},
     entity::Entity,
     world::{
         unsafe_world_cell::UnsafeEntityCell, EntityMut, EntityWorldMut, FilteredEntityMut,
@@ -119,6 +119,8 @@ pub struct ReflectComponentFns {
     pub reflect_unchecked_mut: unsafe fn(UnsafeEntityCell<'_>) -> Option<Mut<'_, dyn Reflect>>,
     /// Function pointer implementing [`ReflectComponent::copy()`].
     pub copy: fn(&World, &mut World, Entity, Entity, &TypeRegistry),
+    /// Function pointer implementing [`ReflectComponent::register_component()`].
+    pub register_component: fn(&mut World) -> ComponentId,
 }
 
 impl ReflectComponentFns {
@@ -220,6 +222,11 @@ impl ReflectComponent {
         );
     }
 
+    /// Register the type of this [`Component`] in [`World`], returning its [`ComponentId`].
+    pub fn register_component(&self, world: &mut World) -> ComponentId {
+        (self.0.register_component)(world)
+    }
+
     /// Create a custom implementation of [`ReflectComponent`].
     ///
     /// This is an advanced feature,
@@ -303,6 +310,9 @@ impl<C: Component + Reflect + TypePath> FromType<C> for ReflectComponent {
                 let c = unsafe { entity.get_mut::<C>() };
                 c.map(|c| c.map_unchanged(|value| value as &mut dyn Reflect))
             },
+            register_component: |world: &mut World| -> ComponentId {
+                world.register_component::<C>()
+            },
         })
     }
 }

crates/bevy_ecs/src/reflect/resource.rs

@@ -6,6 +6,7 @@
 
 use crate::{
     change_detection::Mut,
+    component::ComponentId,
     system::Resource,
     world::{unsafe_world_cell::UnsafeWorldCell, World},
 };
@@ -59,6 +60,8 @@ pub struct ReflectResourceFns {
     pub reflect_unchecked_mut: unsafe fn(UnsafeWorldCell<'_>) -> Option<Mut<'_, dyn Reflect>>,
     /// Function pointer implementing [`ReflectResource::copy()`].
     pub copy: fn(&World, &mut World, &TypeRegistry),
+    /// Function pointer implementing [`ReflectResource::register_resource()`].
+    pub register_resource: fn(&mut World) -> ComponentId,
 }
 
 impl ReflectResourceFns {
@@ -145,6 +148,11 @@ impl ReflectResource {
         (self.0.copy)(source_world, destination_world, registry);
     }
 
+    /// Register the type of this [`Resource`] in [`World`], returning the [`ComponentId`]
+    pub fn register_resource(&self, world: &mut World) -> ComponentId {
+        (self.0.register_resource)(world)
+    }
+
     /// Create a custom implementation of [`ReflectResource`].
     ///
     /// This is an advanced feature,
@@ -217,6 +225,10 @@ impl<R: Resource + FromReflect + TypePath> FromType<R> for ReflectResource {
                     from_reflect_with_fallback::<R>(source_resource, destination_world, registry);
                 destination_world.insert_resource(destination_resource);
             },
+
+            register_resource: |world: &mut World| -> ComponentId {
+                world.register_resource::<R>()
+            },
         })
     }
 }

crates/bevy_ecs/src/world/mod.rs

@@ -334,6 +334,25 @@ impl World {
         self.components.component_id::<T>()
     }
 
+    /// Registers a new [`Resource`] type and returns the [`ComponentId`] created for it.
+    ///
+    /// Note that the resource doesn't have a value in world, it's only registered.
+    /// if you want to insert the [`Resource`] in the [`World`], use [`World::init_resource`] or [`World::insert_resource`] instead.
+    pub fn register_resource<R: Resource>(&mut self) -> ComponentId {
+        self.components.register_resource::<R>()
+    }
+
+    /// Returns the [`ComponentId`] of the given [`Resource`] type `T`.
+    ///
+    /// The returned `ComponentId` is specific to the `World` instance
+    /// it was retrieved from and should not be used with another `World` instance.
+    ///
+    /// Returns [`None`] if the `Resource` type has not yet been initialized within
+    /// the `World` using [`World::register_resource`], [`World::init_resource`] or [`World::insert_resource`].
+    pub fn resource_id<T: Resource>(&self) -> Option<ComponentId> {
+        self.components.get_resource_id(TypeId::of::<T>())
+    }
+
     /// Retrieves an [`EntityRef`] that exposes read-only operations for the given `entity`.
     /// This will panic if the `entity` does not exist. Use [`World::get_entity`] if you want
     /// to check for entity existence instead of implicitly panic-ing.