Optimize cloning for Access-related structs (#14502)

# Objective

Optimize the cloning process for Access-related structs in the ECS
system, specifically targeting the `clone_from` method.

Previously, profiling showed that 1% of CPU time was spent in
`FixedBitSet`'s `drop_in_place`, due to the default `clone_from`
implementation:

```rust
fn clone_from(&mut self, source: &Self) {
    *self = source.clone()
}
```

This implementation causes unnecessary allocations and deallocations.
However, [FixedBitSet provides a more optimized clone_from
method](https://github.com/petgraph/fixedbitset/blob/master/src/lib.rs#L1445-L1465)
that avoids these allocations and utilizes SIMD instructions for better
performance.

This PR aims to leverage the optimized clone_from method of FixedBitSet
and implement custom clone_from methods for Access-related structs to
take full advantage of this optimization. By doing so, we expect to
significantly reduce CPU time spent on cloning operations and improve
overall system performance.



![image](https://github.com/user-attachments/assets/7526a5c5-c75b-4a9a-b8d2-891f64fd553b)


## Solution

- Implemented custom `clone` and `clone_from` methods for `Access`,
`FilteredAccess`, `AccessFilters`, and `FilteredAccessSet` structs.
- Removed `#[derive(Clone)]` and manually implemented `Clone` trait to
use optimized `clone_from` method from `FixedBitSet`.
- Added unit tests for cloning and `clone_from` methods to ensure
correctness.

## Testing

- Conducted performance testing comparing the original and optimized
versions.
- Measured CPU time consumption for the `clone_from` method:
  - Original version: 1.34% of CPU time
  - Optimized version: 0.338% of CPU time
- Compared FPS before and after the changes (results may vary depending
on the run):

Before optimization:
```
2024-07-28T12:49:11.864019Z  INFO bevy diagnostic: fps        :  213.489463   (avg 214.502488)
2024-07-28T12:49:11.864037Z  INFO bevy diagnostic: frame_time :    4.704746ms (avg 4.682251ms)
2024-07-28T12:49:11.864042Z  INFO bevy diagnostic: frame_count: 7947.000000   (avg 7887.500000)
```


![image](https://github.com/user-attachments/assets/7865a365-0569-4b46-814a-964779d90973)

After optimization:
```
2024-07-28T12:29:42.705738Z  INFO bevy diagnostic: fps        :  220.273721   (avg 220.912227)
2024-07-28T12:29:42.705762Z  INFO bevy diagnostic: frame_time :    4.559127ms (avg 4.544905ms)
2024-07-28T12:29:42.705769Z  INFO bevy diagnostic: frame_count: 7596.000000   (avg 7536.500000)
```


![image](https://github.com/user-attachments/assets/8dd96908-86d0-4850-8e29-f80176a005d6)

---

Reviewers can test these changes by running `cargo run --release
--example ssr`

crates/bevy_ecs/src/query/access.rs

@@ -47,7 +47,7 @@ impl<'a, T: SparseSetIndex + fmt::Debug> fmt::Debug for FormattedBitSet<'a, T> {
 ///
 /// Used internally to ensure soundness during system initialization and execution.
 /// See the [`is_compatible`](Access::is_compatible) and [`get_conflicts`](Access::get_conflicts) functions.
-#[derive(Clone, Eq, PartialEq)]
+#[derive(Eq, PartialEq)]
 pub struct Access<T: SparseSetIndex> {
     /// All accessed elements.
     reads_and_writes: FixedBitSet,
@@ -64,6 +64,28 @@ pub struct Access<T: SparseSetIndex> {
     marker: PhantomData<T>,
 }
 
+// This is needed since `#[derive(Clone)]` does not generate optimized `clone_from`.
+impl<T: SparseSetIndex> Clone for Access<T> {
+    fn clone(&self) -> Self {
+        Self {
+            reads_and_writes: self.reads_and_writes.clone(),
+            writes: self.writes.clone(),
+            reads_all: self.reads_all,
+            writes_all: self.writes_all,
+            archetypal: self.archetypal.clone(),
+            marker: PhantomData,
+        }
+    }
+
+    fn clone_from(&mut self, source: &Self) {
+        self.reads_and_writes.clone_from(&source.reads_and_writes);
+        self.writes.clone_from(&source.writes);
+        self.reads_all = source.reads_all;
+        self.writes_all = source.writes_all;
+        self.archetypal.clone_from(&source.archetypal);
+    }
+}
+
 impl<T: SparseSetIndex + fmt::Debug> fmt::Debug for Access<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Access")
@@ -325,7 +347,7 @@ impl<T: SparseSetIndex> Access<T> {
 /// - `Query<Option<&T>>` accesses nothing
 ///
 /// See comments the [`WorldQuery`](super::WorldQuery) impls of [`AnyOf`](super::AnyOf)/`Option`/[`Or`](super::Or) for more information.
-#[derive(Debug, Clone, Eq, PartialEq)]
+#[derive(Debug, Eq, PartialEq)]
 pub struct FilteredAccess<T: SparseSetIndex> {
     pub(crate) access: Access<T>,
     pub(crate) required: FixedBitSet,
@@ -334,6 +356,23 @@ pub struct FilteredAccess<T: SparseSetIndex> {
     pub(crate) filter_sets: Vec<AccessFilters<T>>,
 }
 
+// This is needed since `#[derive(Clone)]` does not generate optimized `clone_from`.
+impl<T: SparseSetIndex> Clone for FilteredAccess<T> {
+    fn clone(&self) -> Self {
+        Self {
+            access: self.access.clone(),
+            required: self.required.clone(),
+            filter_sets: self.filter_sets.clone(),
+        }
+    }
+
+    fn clone_from(&mut self, source: &Self) {
+        self.access.clone_from(&source.access);
+        self.required.clone_from(&source.required);
+        self.filter_sets.clone_from(&source.filter_sets);
+    }
+}
+
 impl<T: SparseSetIndex> Default for FilteredAccess<T> {
     fn default() -> Self {
         Self::matches_everything()
@@ -526,13 +565,29 @@ impl<T: SparseSetIndex> FilteredAccess<T> {
     }
 }
 
-#[derive(Clone, Eq, PartialEq)]
+#[derive(Eq, PartialEq)]
 pub(crate) struct AccessFilters<T> {
     pub(crate) with: FixedBitSet,
     pub(crate) without: FixedBitSet,
     _index_type: PhantomData<T>,
 }
 
+// This is needed since `#[derive(Clone)]` does not generate optimized `clone_from`.
+impl<T: SparseSetIndex> Clone for AccessFilters<T> {
+    fn clone(&self) -> Self {
+        Self {
+            with: self.with.clone(),
+            without: self.without.clone(),
+            _index_type: PhantomData,
+        }
+    }
+
+    fn clone_from(&mut self, source: &Self) {
+        self.with.clone_from(&source.with);
+        self.without.clone_from(&source.without);
+    }
+}
+
 impl<T: SparseSetIndex + fmt::Debug> fmt::Debug for AccessFilters<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("AccessFilters")
@@ -570,12 +625,27 @@ impl<T: SparseSetIndex> AccessFilters<T> {
 /// It stores multiple sets of accesses.
 /// - A "combined" set, which is the access of all filters in this set combined.
 /// - The set of access of each individual filters in this set.
-#[derive(Debug, Clone)]
+#[derive(Debug, PartialEq, Eq)]
 pub struct FilteredAccessSet<T: SparseSetIndex> {
     combined_access: Access<T>,
     filtered_accesses: Vec<FilteredAccess<T>>,
 }
 
+// This is needed since `#[derive(Clone)]` does not generate optimized `clone_from`.
+impl<T: SparseSetIndex> Clone for FilteredAccessSet<T> {
+    fn clone(&self) -> Self {
+        Self {
+            combined_access: self.combined_access.clone(),
+            filtered_accesses: self.filtered_accesses.clone(),
+        }
+    }
+
+    fn clone_from(&mut self, source: &Self) {
+        self.combined_access.clone_from(&source.combined_access);
+        self.filtered_accesses.clone_from(&source.filtered_accesses);
+    }
+}
+
 impl<T: SparseSetIndex> FilteredAccessSet<T> {
     /// Returns a reference to the unfiltered access of the entire set.
     #[inline]
@@ -696,6 +766,136 @@ mod tests {
     use fixedbitset::FixedBitSet;
     use std::marker::PhantomData;
 
+    fn create_sample_access() -> Access<usize> {
+        let mut access = Access::<usize>::default();
+
+        access.add_read(1);
+        access.add_read(2);
+        access.add_write(3);
+        access.add_archetypal(5);
+        access.read_all();
+
+        access
+    }
+
+    fn create_sample_filtered_access() -> FilteredAccess<usize> {
+        let mut filtered_access = FilteredAccess::<usize>::default();
+
+        filtered_access.add_write(1);
+        filtered_access.add_read(2);
+        filtered_access.add_required(3);
+        filtered_access.and_with(4);
+
+        filtered_access
+    }
+
+    fn create_sample_access_filters() -> AccessFilters<usize> {
+        let mut access_filters = AccessFilters::<usize>::default();
+
+        access_filters.with.grow_and_insert(3);
+        access_filters.without.grow_and_insert(5);
+
+        access_filters
+    }
+
+    fn create_sample_filtered_access_set() -> FilteredAccessSet<usize> {
+        let mut filtered_access_set = FilteredAccessSet::<usize>::default();
+
+        filtered_access_set.add_unfiltered_read(2);
+        filtered_access_set.add_unfiltered_write(4);
+        filtered_access_set.read_all();
+
+        filtered_access_set
+    }
+
+    #[test]
+    fn test_access_clone() {
+        let original: Access<usize> = create_sample_access();
+        let cloned = original.clone();
+
+        assert_eq!(original, cloned);
+    }
+
+    #[test]
+    fn test_access_clone_from() {
+        let original: Access<usize> = create_sample_access();
+        let mut cloned = Access::<usize>::default();
+
+        cloned.add_write(7);
+        cloned.add_read(4);
+        cloned.add_archetypal(8);
+        cloned.write_all();
+
+        cloned.clone_from(&original);
+
+        assert_eq!(original, cloned);
+    }
+
+    #[test]
+    fn test_filtered_access_clone() {
+        let original: FilteredAccess<usize> = create_sample_filtered_access();
+        let cloned = original.clone();
+
+        assert_eq!(original, cloned);
+    }
+
+    #[test]
+    fn test_filtered_access_clone_from() {
+        let original: FilteredAccess<usize> = create_sample_filtered_access();
+        let mut cloned = FilteredAccess::<usize>::default();
+
+        cloned.add_write(7);
+        cloned.add_read(4);
+        cloned.append_or(&FilteredAccess::default());
+
+        cloned.clone_from(&original);
+
+        assert_eq!(original, cloned);
+    }
+
+    #[test]
+    fn test_access_filters_clone() {
+        let original: AccessFilters<usize> = create_sample_access_filters();
+        let cloned = original.clone();
+
+        assert_eq!(original, cloned);
+    }
+
+    #[test]
+    fn test_access_filters_clone_from() {
+        let original: AccessFilters<usize> = create_sample_access_filters();
+        let mut cloned = AccessFilters::<usize>::default();
+
+        cloned.with.grow_and_insert(1);
+        cloned.without.grow_and_insert(2);
+
+        cloned.clone_from(&original);
+
+        assert_eq!(original, cloned);
+    }
+
+    #[test]
+    fn test_filtered_access_set_clone() {
+        let original: FilteredAccessSet<usize> = create_sample_filtered_access_set();
+        let cloned = original.clone();
+
+        assert_eq!(original, cloned);
+    }
+
+    #[test]
+    fn test_filtered_access_set_from() {
+        let original: FilteredAccessSet<usize> = create_sample_filtered_access_set();
+        let mut cloned = FilteredAccessSet::<usize>::default();
+
+        cloned.add_unfiltered_read(7);
+        cloned.add_unfiltered_write(9);
+        cloned.write_all();
+
+        cloned.clone_from(&original);
+
+        assert_eq!(original, cloned);
+    }
+
     #[test]
     fn read_all_access_conflicts() {
         // read_all / single write