Guard against VisibilityClass being duplicated while cloning (#21069)

# Objective

- This is the second attempt at "Fixes #20884" after conversation in
#20891

## Solution

- I followed the approach discussed in #20891 to add
`#[component(clone_behavior=Ignore)]` to avoid cloning this Component

## Testing

- I tested the change with a simple repro. I'm not sure if I can unit
test just the existence of this line but I'll see if I can and update
accordingly.

```rust
use bevy::{prelude::*, render::view::NoIndirectDrawing};
fn main() {
    App::new()
        .insert_resource(ClearColor(Color::BLACK))
        .add_plugins(DefaultPlugins)
        .add_systems(Startup, startup)
        .run();
}
fn startup(
    mut cmd: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    mut al: ResMut<AmbientLight>,
) {
    al.brightness = 5000.;
    cmd.spawn((
        Mesh3d(meshes.add(Cuboid::from_size(Vec3::new(4., 0.5, 0.1)))),
        MeshMaterial3d(materials.add(Color::srgb(1., 1., 0.))),
        Transform::from_xyz(0., 0., -2.),
    ));
    let mut id = cmd.spawn((
        Mesh3d(meshes.add(Cuboid::from_length(1.))),
        MeshMaterial3d(materials.add(Color::srgba(0., 0., 1., 0.5))),
        Transform::from_xyz(-0.5, 0., 0.),
    ));
    id.clone_and_spawn()
        .insert(Transform::from_xyz(0.5, 0., 0.));
    cmd.spawn((
        Camera3d::default(),
        Transform::from_xyz(0., 0., 10.).looking_at(Vec3::ZERO, Vec3::Y),
        NoIndirectDrawing,
    ));
}
```
## Showcase


Before
<img width="178" height="202"
alt="486232152-9f8685f6-fbc3-4bc1-b9bd-7e28177cc901"
src="https://github.com/user-attachments/assets/2bca4f28-b956-49dc-83b4-edefef6ca595"
/>

After
<img width="120" height="173"
alt="486232412-bafd5e4a-69be-4249-894a-5f03dfe28b63"
src="https://github.com/user-attachments/assets/1b911bb6-01c4-451a-b010-20aab505217e"
/>

Co-authored-by: Dimitrios Loukadakis <[email protected]>

Author: it-me-joda

crates/bevy_camera/src/visibility/mod.rs

@@ -150,11 +150,16 @@ impl InheritedVisibility {
 /// When adding a new renderable component, you'll typically want to write an
 /// add-component hook that adds the type ID of that component to the
 /// [`VisibilityClass`] array. See `custom_phase_item` for an example.
+///
+/// `VisibilityClass` is automatically added by a hook on the `Mesh3d` and
+/// `Mesh2d` components. To avoid duplicating the `VisibilityClass` and
+/// causing issues when cloning, we use `#[component(clone_behavior=Ignore)]`
 //
 // Note: This can't be a `ComponentId` because the visibility classes are copied
 // into the render world, and component IDs are per-world.
 #[derive(Clone, Component, Default, Reflect, Deref, DerefMut)]
 #[reflect(Component, Default, Clone)]
+#[component(clone_behavior=Ignore)]
 pub struct VisibilityClass(pub SmallVec<[TypeId; 1]>);
 
 /// Algorithmically-computed indication of whether an entity is visible and should be extracted for rendering.
@@ -988,4 +993,27 @@ mod test {
         assert_eq!(1, size_of::<Visibility>());
         assert_eq!(1, size_of::<Option<Visibility>>());
     }
+
+    #[derive(Component, Default, Clone, Reflect)]
+    #[require(VisibilityClass)]
+    #[reflect(Component, Default, Clone)]
+    #[component(on_add = add_visibility_class::<Self>)]
+    struct TestVisibilityClassHook;
+
+    #[test]
+    fn test_add_visibility_class_hook() {
+        let mut world = World::new();
+        let entity = world.spawn(TestVisibilityClassHook).id();
+        let entity_clone = world.spawn_empty().id();
+        world
+            .entity_mut(entity)
+            .clone_with_opt_out(entity_clone, |_| {});
+
+        let entity_visibility_class = world.entity(entity).get::<VisibilityClass>().unwrap();
+        assert_eq!(entity_visibility_class.len(), 1);
+
+        let entity_clone_visibility_class =
+            world.entity(entity_clone).get::<VisibilityClass>().unwrap();
+        assert_eq!(entity_clone_visibility_class.len(), 1);
+    }
 }