Optimize and fix sphere-OBB intersection logic (#23865)

# Objective

- Optimize the Sphere and OOB intersection logic.
- Fix a bug when the sphere and OBB shared the exact same center.

## Solution

- The previous implementation calculated `v / d` (a normalized vector).
If the distance `d` was zero (in a situation when centers are
identical), this resulted in a division by zero. The new approach avoids
normalization by refactoring the comparison.
- Original: $d < r_1 + r_2$ where $r_2 =$
`relative_radius`$\Bigl(\frac{\mathbf{v}}{d}\Bigr)$
- New: $d^2 \leq r \cdot d + r_{\rm unscaled}$ where $r_{\rm unscaled}
=$ `relative_radius`$(\mathbf{v})$

## Testing

- Added new test cases covering identical centers, edge contacts, and
zero-extent volumes. These tests fail on main but pass with this PR.
- Verified performance via the newly added camera benchmarks in
#23863

```
intersects_obb/sphere_intersects_obb
                        time:   [5.3677 ns 5.3932 ns 5.4227 ns]
                        change: [−19.462% −18.945% −18.426%] (p = 0.00 < 0.05)
                        Performance has improved.
```

Author: CrazyRoka

crates/bevy_camera/src/primitives.rs

@@ -218,9 +218,10 @@ impl Sphere {
     pub fn intersects_obb(&self, aabb: &Aabb, world_from_local: &Affine3A) -> bool {
         let aabb_center_world = world_from_local.transform_point3a(aabb.center);
         let v = aabb_center_world - self.center;
-        let d = v.length();
-        let relative_radius = aabb.relative_radius(&(v / d), &world_from_local.matrix3);
-        d < self.radius + relative_radius
+        let d_sq = v.length_squared();
+        let d = d_sq.sqrt();
+        let relative_radius_unscaled = aabb.relative_radius(&v, &world_from_local.matrix3);
+        d_sq <= self.radius * d + relative_radius_unscaled
     }
 }
 
@@ -608,6 +609,80 @@ mod tests {
         assert!(frustum.intersects_sphere(&sphere, true));
     }
 
+    #[test]
+    fn sphere_intersects_obb_identical_center() {
+        let sphere_at_origin = Sphere {
+            center: Vec3A::ZERO,
+            radius: 1.0,
+        };
+        let aabb_at_origin = Aabb {
+            center: Vec3A::ZERO,
+            half_extents: Vec3A::splat(0.5),
+        };
+        assert!(
+            sphere_at_origin.intersects_obb(&aabb_at_origin, &Affine3A::IDENTITY),
+            "Should intersect when centers are exactly identical"
+        );
+    }
+
+    #[test]
+    fn sphere_intersects_obb_at_edge() {
+        // Zero-radius sphere (a point) exactly on the edge of an OBB
+        let point_sphere = Sphere {
+            center: Vec3A::new(1.0, 0.0, 0.0),
+            radius: 0.0,
+        };
+        let aabb = Aabb {
+            center: Vec3A::ZERO,
+            half_extents: Vec3A::X, // Width of 1, height/depth 0
+        };
+        assert!(
+            point_sphere.intersects_obb(&aabb, &Affine3A::IDENTITY),
+            "Zero radius sphere (point) on the boundary should count as an intersection"
+        );
+    }
+
+    #[test]
+    fn sphere_intersects_obb_zero_extents_inside() {
+        // OBB with zero extents (a point) inside a sphere
+        let sphere = Sphere {
+            center: Vec3A::ZERO,
+            radius: 10.0,
+        };
+        let point_aabb = Aabb {
+            center: Vec3A::new(1.0, 1.0, 1.0),
+            half_extents: Vec3A::ZERO,
+        };
+        assert!(
+            sphere.intersects_obb(&point_aabb, &Affine3A::IDENTITY),
+            "Sphere should intersect an AABB with zero extents if the point is inside"
+        );
+    }
+
+    #[test]
+    fn sphere_intersects_obb_rotated_zeros() {
+        // Rotated zero-extent OBB
+        let sphere = Sphere {
+            center: Vec3A::new(5.0, 0.0, 0.0),
+            radius: 1.0,
+        };
+        let point_aabb = Aabb {
+            center: Vec3A::ZERO,
+            half_extents: Vec3A::ZERO,
+        };
+
+        // Rotate and translate the "point" OBB so it sits inside the sphere
+        let transform = Affine3A::from_rotation_translation(
+            Quat::from_rotation_y(PI),
+            Vec3::new(5.0, 0.0, 0.0),
+        );
+
+        assert!(
+            sphere.intersects_obb(&point_aabb, &transform),
+            "Should intersect rotated point OBB"
+        );
+    }
+
     #[test]
     fn aabb_enclosing() {
         assert_eq!(Aabb::enclosing([] as [Vec3; 0]), None);