bevy_scene: Use FromReflect on extracted resources (#15753)

# Objective

Fixes #15726

The extraction logic for components makes use of `FromReflect` to try
and ensure we have a concrete type for serialization. However, we did
not do the same for resources.

The reason we're seeing this for the glam types is that #15174 also made
a change to rely on the glam type's `Serialize` and `Deserialize` impls,
which I don't think should have been merged (I'll put up a PR addressing
this specifically soon).

## Solution

Use `FromReflect` on extracted resources.

## Testing

You can test locally by running:

```
cargo test --package bevy_scene
```

crates/bevy_scene/src/dynamic_scene_builder.rs

@@ -365,12 +365,19 @@ impl<'w> DynamicSceneBuilder<'w> {
  return None;
  }
 
- let resource = type_registry
- .get(type_id)?
+ let type_registration = type_registry.get(type_id)?;
+
+ let resource = type_registration
  .data::<ReflectResource>()?
  .reflect(self.original_world)?;
- self.extracted_resources
- .insert(component_id, resource.clone_value());
+
+ let resource = type_registration
+ .data::<ReflectFromReflect>()
+ .and_then(|fr| fr.from_reflect(resource.as_partial_reflect()))
+ .map(PartialReflect::into_partial_reflect)
+ .unwrap_or_else(|| resource.clone_value());
+
+ self.extracted_resources.insert(component_id, resource);
  Some(())
  };
  extract_and_push();
@@ -688,4 +695,39 @@ mod tests {
  assert_eq!(scene.resources.len(), 1);
  assert!(scene.resources[0].represents::<ResourceB>());
  }
+
+ #[test]
+ fn should_use_from_reflect() {
+ #[derive(Resource, Component, Reflect)]
+ #[reflect(Resource, Component)]
+ struct SomeType(i32);
+
+ let mut world = World::default();
+ let atr = AppTypeRegistry::default();
+ {
+ let mut register = atr.write();
+ register.register::<SomeType>();
+ }
+ world.insert_resource(atr);
+
+ world.insert_resource(SomeType(123));
+ let entity = world.spawn(SomeType(123)).id();
+
+ let scene = DynamicSceneBuilder::from_world(&world)
+ .extract_resources()
+ .extract_entities(vec![entity].into_iter())
+ .build();
+
+ let component = &scene.entities[0].components[0];
+ assert!(component
+ .try_as_reflect()
+ .expect("component should be concrete due to `FromReflect`")
+ .is::<SomeType>());
+
+ let resource = &scene.resources[0];
+ assert!(resource
+ .try_as_reflect()
+ .expect("resource should be concrete due to `FromReflect`")
+ .is::<SomeType>());
+ }
 }