fix: Keep Android CSS :hover active while the pointer is over descendant views (#9718)

## Summary

Android `:hover` toggled only the view that received the event, so
moving the pointer onto a hoverable descendant fired `ACTION_HOVER_EXIT`
on the ancestor and cleared its `:hover`. It's now recomputed from the
pointer position on enter/exit, so an ancestor stays hovered while the
pointer is over a descendant (matching `:active`). Also removes
`elevation: 2` from the Showcase action buttons, which Android drew as
an opaque white rectangle inside the rounded border.

| Before | After |
|-|-|
| <video
src="https://github.com/user-attachments/assets/bf11b5fa-fbee-46a3-b167-18f04e4ade54"
/> | <video
src="https://github.com/user-attachments/assets/910a6ef5-1f1c-4a3a-9b8e-92be702f7ea7"
/> |

## Test plan

Verified on a physical Samsung S26 Ultra using its S-pen.

Author: MatiPl01

apps/common-app/src/apps/css/examples/transitions/screens/pseudoSelectors/Showcase.tsx

@@ -155,7 +155,6 @@ const styles = StyleSheet.create({
   actionBtn: {
     borderRadius: radius.md,
     borderWidth: 1,
-    elevation: 2,
     paddingHorizontal: spacing.md,
     paddingVertical: spacing.sm,
     shadowOffset: { height: 0, width: 0 },

packages/react-native-reanimated/android/src/main/java/com/swmansion/reanimated/pseudoSelectors/PseudoSelectorManager.kt

@@ -17,6 +17,13 @@ class PseudoSelectorManager(
 
     private val activeDeepestViews = LinkedHashSet<View>()
 
+    private val hoverCallbacks = LinkedHashMap<View, PseudoSelectorCallback>()
+
+    private val hoveredViews = LinkedHashSet<View>()
+
+    // Reused by updateHoverStates to avoid allocating on every hover event (UI thread only).
+    private val hoverLocationBuffer = IntArray(2)
+
     fun attach(
         tag: Int,
         selector: Int,
@@ -84,18 +91,28 @@ class PseudoSelectorManager(
         key: String,
         callback: PseudoSelectorCallback,
     ) {
+        // Android fires ACTION_HOVER_EXIT on an ancestor when the pointer moves onto a
+        // hoverable descendant, but CSS :hover must stay active there. So on enter/exit
+        // (not per-frame MOVE) recompute every registered view from the pointer position.
+        hoverCallbacks[view] = callback
         val listener =
             View.OnHoverListener { _, event ->
-                val action = event.actionMasked
-                if (action == MotionEvent.ACTION_HOVER_ENTER) {
-                    callback.onSelectorStateChanged(true)
-                } else if (action == MotionEvent.ACTION_HOVER_EXIT) {
-                    callback.onSelectorStateChanged(false)
+                when (event.actionMasked) {
+                    MotionEvent.ACTION_HOVER_ENTER,
+                    MotionEvent.ACTION_HOVER_EXIT,
+                    -> updateHoverStates(event.rawX, event.rawY)
                 }
                 false
             }
         view.setOnHoverListener(listener)
-        detachActions[key] = Runnable { view.setOnHoverListener(null) }
+        detachActions[key] =
+            Runnable {
+                hoverCallbacks.remove(view)
+                if (hoveredViews.remove(view)) {
+                    callback.onSelectorStateChanged(false)
+                }
+                view.setOnHoverListener(null)
+            }
     }
 
     private fun attachActive(
@@ -200,6 +217,32 @@ class PseudoSelectorManager(
         }
     }
 
+    /**
+     * Recompute every registered view's _:hover_ state from the pointer position, firing only on
+     * change. A view is hovered while the point is in its on-screen bounds - true for an ancestor
+     * while the pointer is over a descendant. Uses live (mid-animation) `getLocationOnScreen` bounds.
+     */
+    private fun updateHoverStates(
+        rawX: Float,
+        rawY: Float,
+    ) {
+        val loc = hoverLocationBuffer
+        for ((view, callback) in hoverCallbacks) {
+            view.getLocationOnScreen(loc)
+            val contains =
+                rawX >= loc[0] && rawX <= loc[0] + view.width &&
+                    rawY >= loc[1] && rawY <= loc[1] + view.height
+            val wasHovered = hoveredViews.contains(view)
+            if (contains && !wasHovered) {
+                hoveredViews.add(view)
+                callback.onSelectorStateChanged(true)
+            } else if (!contains && wasHovered) {
+                hoveredViews.remove(view)
+                callback.onSelectorStateChanged(false)
+            }
+        }
+    }
+
     private fun isDescendantOf(
         view: View,
         ancestor: View,