add ReflectFromTemplate and ReflectTemplate

[AwfulToTheEar]

Objective

implementation for issue (#24870)

Solution

Add ReflectFromTemplate and ReflectTemplate for creating Templates and their Output from reflection.
Derive Reflect for all Templates and Reflect FromTemplate and Template.

Testing

Added test for fetching the associated ReflectTemplate for a reflected struct and creating the struct.

---

Showcase

#[derive(Component, Reflect, Default, Clone)]
#[Component, FromTemplate]
struct MyStruct {
    foo: i32
}

//fetch template associated with MyStruct
let my_struct_registration = registry.get(TypeId::of::<MyStruct>()).unwrap();
let reflect_from_template = my_struct_registration.data::<ReflectFromTemplate>().unwrap();

//create template
let my_struct_template_registration = reflect_from_template.get_template(&registry).unwrap();
let reflect_template = my_struct_template_registration.data::<ReflectTemplate>().unwrap();
let reflect_default = my_struct_template_registration.data::<ReflectDefault>().unwrap();

let template = reflect_default.default();

//build MyStruct
let mut entity = world.spawn_empty();
let mut scene_entity_references = SceneEntityReferences::default();
let mut template_context = TemplateContext::new(
    &mut entity,
    &mut scene_entity_references
);
let my_struct_reflect = reflect_template.build(
    &mut template_context,
    template.as_partial_reflect(),
    &registry
).unwrap();
let my_struct = my_struct_reflect.downcast::<MyStruct>().unwrap();

[github-actions]

Welcome, new contributor!

Please make sure you've read our contributing guide, as well as our policy regarding AI usage, and we look forward to reviewing your pull request shortly ✨

[MrGVSV]

Looking good! I left some minor nitpicks. Can we also add docs and format the code please?

[MrGVSV]

I honestly had no clue you could do impl Reflect here. How does this differ from writing Template<Output: Reflect>?

[AwfulToTheEar]

I checked and, writing <Output: Reflect> doesn't work, it needs to be either dyn Reflect or impl Reflect

[MrGVSV]

Nit: We should probably update the name to be plural

Suggested change

	pub fn fn_pointer(&self) -> &ReflectTemplateFns {
	pub fn fn_pointers(&self) -> &ReflectTemplateFns {

[MrGVSV]

Nit: I don't think the call to clone is needed here

Suggested change

	foo: self.foo.clone()
	foo: self.foo

[MrGVSV]

Personally, I think we should just manually register types in tests. It's simpler, more explicit, and doesn't rely on automatic-registration working properly (in the case reflect_auto_register is enabled).

Suggested change

	#[cfg(feature = "reflect_auto_register")]
	registry.register_derived_types();
	#[cfg(not(feature = "reflect_auto_register"))]
	{
	registry.register::<MyStruct>();
	registry.register_type_data::<MyStruct, ReflectFromTemplate>();
	registry.register::<MyStructTemplate>();
	registry.register_type_data::<MyStructTemplate, ReflectTemplate>();
	registry.register_type_data::<MyStructTemplate, ReflectDefault>();
	}
	registry.register::<MyStruct>();
	registry.register_type_data::<MyStruct, ReflectFromTemplate>();
	registry.register::<MyStructTemplate>();
	registry.register_type_data::<MyStructTemplate, ReflectTemplate>();
	registry.register_type_data::<MyStructTemplate, ReflectDefault>();

[MrGVSV]

Nit: I think we should also be able to automatically upcast like &*template (i.e. dereference the Box). We're working to deprecate these methods (see #21772).

[MrGVSV]

Nit: The * should be enough to dereference the Box

Suggested change

	*my_struct.deref(),
	*my_struct,

[MrGVSV]

Nit: Same here, can we make this plural?

Suggested change

	pub fn fn_pointer(&self) -> &ReflectFromTemplateFns {
	pub fn fn_pointers(&self) -> &ReflectFromTemplateFns {