Reduce reflect size (#22592)

# Objective

After #22452 is merged, the binary size increased a lot (and also
compile time). Try to decrease binary size again.

## Solution

Change the methods from generic to non-generic.

## Testing


compile `3d_shapes` example on macOS:

* before #22452 :  94.5mb
* at #22452 : 97.7mb
* at #22452 + to dynamic (another attempt) : 94.9mb
* at #22452 + dyn (**this PR**) : 94.5mb

also tried to see what if we disable reflection based cmp/eq entirely
(which makes tests fails):

* disable reflection based cmp/eq entirely: 94.1mb

Author: molikto

crates/bevy_reflect/src/enums/helpers.rs

@@ -9,8 +9,8 @@ use core::{
 };
 
 /// Returns the `u64` hash of the given [enum](Enum).
-#[inline]
-pub fn enum_hash<TEnum: Enum>(value: &TEnum) -> Option<u64> {
+#[inline(never)]
+pub fn enum_hash(value: &dyn Enum) -> Option<u64> {
     let mut hasher = reflect_hasher();
     core::any::Any::type_id(value).hash(&mut hasher);
     value.variant_name().hash(&mut hasher);
@@ -29,8 +29,8 @@ pub fn enum_hash<TEnum: Enum>(value: &TEnum) -> Option<u64> {
 /// - For each field in `a`, `b` contains a field with the same name and
 ///   [`PartialReflect::reflect_partial_eq`] returns `Some(true)` for the two field
 ///   values.
-#[inline]
-pub fn enum_partial_eq<TEnum: Enum + ?Sized>(a: &TEnum, b: &dyn PartialReflect) -> Option<bool> {
+#[inline(never)]
+pub fn enum_partial_eq(a: &dyn Enum, b: &dyn PartialReflect) -> Option<bool> {
     // Both enums?
     let ReflectRef::Enum(b) = b.reflect_ref() else {
         return Some(false);
@@ -94,11 +94,8 @@ pub fn enum_partial_eq<TEnum: Enum + ?Sized>(a: &TEnum, b: &dyn PartialReflect)
 /// or an element comparison returns `None`).
 ///
 /// The ordering is same with `derive` macro. First order by variant index, then by fields.
-#[inline]
-pub fn enum_partial_cmp<TEnum: Enum + ?Sized>(
-    a: &TEnum,
-    b: &dyn PartialReflect,
-) -> Option<::core::cmp::Ordering> {
+#[inline(never)]
+pub fn enum_partial_cmp(a: &dyn Enum, b: &dyn PartialReflect) -> Option<::core::cmp::Ordering> {
     // Both enums?
     let ReflectRef::Enum(b) = b.reflect_ref() else {
         return None;

crates/bevy_reflect/src/structs.rs

@@ -516,8 +516,8 @@ impl<'a> IntoIterator for &'a DynamicStruct {
 ///   values.
 ///
 /// Returns [`None`] if the comparison couldn't even be performed.
-#[inline]
-pub fn struct_partial_eq<S: Struct + ?Sized>(a: &S, b: &dyn PartialReflect) -> Option<bool> {
+#[inline(never)]
+pub fn struct_partial_eq(a: &dyn Struct, b: &dyn PartialReflect) -> Option<bool> {
     let ReflectRef::Struct(struct_value) = b.reflect_ref() else {
         return Some(false);
     };
@@ -545,11 +545,8 @@ pub fn struct_partial_eq<S: Struct + ?Sized>(a: &S, b: &dyn PartialReflect) -> O
 ///
 /// Returns [`None`] if the comparison couldn't be performed (e.g., kinds mismatch
 /// or an element comparison returns `None`).
-#[inline]
-pub fn struct_partial_cmp<S: Struct + ?Sized>(
-    a: &S,
-    b: &dyn PartialReflect,
-) -> Option<::core::cmp::Ordering> {
+#[inline(never)]
+pub fn struct_partial_cmp(a: &dyn Struct, b: &dyn PartialReflect) -> Option<::core::cmp::Ordering> {
     let ReflectRef::Struct(struct_value) = b.reflect_ref() else {
         return None;
     };

crates/bevy_reflect/src/tuple_struct.rs

@@ -428,11 +428,8 @@ impl<'a> IntoIterator for &'a DynamicTupleStruct {
 /// - [`PartialReflect::reflect_partial_eq`] returns `Some(true)` for pairwise fields of `a` and `b`.
 ///
 /// Returns [`None`] if the comparison couldn't even be performed.
-#[inline]
-pub fn tuple_struct_partial_eq<S: TupleStruct + ?Sized>(
-    a: &S,
-    b: &dyn PartialReflect,
-) -> Option<bool> {
+#[inline(never)]
+pub fn tuple_struct_partial_eq(a: &dyn TupleStruct, b: &dyn PartialReflect) -> Option<bool> {
     let ReflectRef::TupleStruct(tuple_struct) = b.reflect_ref() else {
         return Some(false);
     };
@@ -454,14 +451,13 @@ pub fn tuple_struct_partial_eq<S: TupleStruct + ?Sized>(
 
     Some(true)
 }
-
 /// Lexicographically compares two [`TupleStruct`] values and returns their ordering.
 ///
 /// Returns [`None`] if the comparison couldn't be performed (e.g., kinds mismatch
 /// or an element comparison returns `None`).
-#[inline]
-pub fn tuple_struct_partial_cmp<S: TupleStruct + ?Sized>(
-    a: &S,
+#[inline(never)]
+pub fn tuple_struct_partial_cmp(
+    a: &dyn TupleStruct,
     b: &dyn PartialReflect,
 ) -> Option<::core::cmp::Ordering> {
     let ReflectRef::TupleStruct(tuple_struct) = b.reflect_ref() else {