[Android] Keep the press alive while a Pressable waits for another gesture (#4639)

## Description

On Android, a `Pressable` with `requireToFail` dropped the whole press
on a quick tap: `onPressIn` fired, `onPressOut` and `onPress` never did.
When the awaited gesture won, the press was left without `onPressOut`
too. iOS was fine.

The long press gesture had an Android-only branch in `onTouchesUp` that
reset the state machine and finalized the press as soon as the finger
lifted. That assumes the button gesture has already finished by then.
With `requireToFail` the button is still awaiting the other gesture when
the finger lifts, so the reset ran first and the button's later FINALIZE
or CANCEL met an empty state machine.

The reset dates from #3571 and never acted on a working path: on a plain
tap, drag-out, scroll steal or parent pan the button finishes first and
`handlePressOut` has already finalized. On Android the native handler
always ends or cancels on pointer up, so the press is always closed
without it. This PR removes the branch, which also removes the
dependency on the orchestrator's delivery order.

The cancel branch added in #4633 loses its iOS gate, so a button
cancelled while the press is held delivers `onPressOut` on every native
platform.

## Test plan

Tested on a Pixel 9 Pro emulator and an iPhone 17 simulator with the
screen below. Tap each box once.

Before, on Android, the second box logs only `onPressIn`. After, both
boxes log `onPressIn`, `onPressOut`, `onPress`. A double tap on the
second box logs `onPressIn`, `onPressOut` and the double tap.

```tsx
import React, { useState } from 'react';
import { StyleSheet, Text, View } from 'react-native';
import {
  GestureDetector,
  GestureHandlerRootView,
  Pressable,
  useTapGesture,
} from 'react-native-gesture-handler';

export default function Repro() {
  const [lines, setLines] = useState<string[]>([]);
  const log = (line: string) =>
    setLines((current) => [...current.slice(-7), line]);

  const doubleTap = useTapGesture({
    numberOfTaps: 2,
    runOnJS: true,
    onActivate: () => log('doubleTap activated'),
  });

  return (
    <GestureHandlerRootView style={styles.container}>
      <Pressable
        onPressIn={() => log('plain: onPressIn')}
        onPressOut={() => log('plain: onPressOut')}
        onPress={() => log('plain: onPress')}>
        <View style={styles.box}>
          <Text>Plain Pressable</Text>
        </View>
      </Pressable>

      <GestureDetector gesture={doubleTap}>
        <View>
          <Pressable
            requireToFail={doubleTap}
            onPressIn={() => log('requireToFail: onPressIn')}
            onPressOut={() => log('requireToFail: onPressOut')}
            onPress={() => log('requireToFail: onPress')}>
            <View style={styles.box}>
              <Text>Pressable with requireToFail</Text>
            </View>
          </Pressable>
        </View>
      </GestureDetector>

      <Text style={styles.log}>{lines.join('\n')}</Text>
    </GestureHandlerRootView>
  );
}

const styles = StyleSheet.create({
  container: { flex: 1, alignItems: 'center', paddingTop: 40, gap: 24 },
  box: {
    width: 300,
    height: 80,
    backgroundColor: '#b58df1',
    alignItems: 'center',
    justifyContent: 'center',
  },
  log: { width: 300, fontSize: 14 },
});
```

Also checked on both platforms that a plain tap, a hold, a drag out of
the box, a disable under the finger, a drag inside an RN and an RNGH
`ScrollView`, a parent pan, a nested `Pressable`, `hitSlop` and
`unstable_pressDelay` behave as before.

Author: m-bert

packages/react-native-gesture-handler/src/v3/components/StatefulPressable.tsx

@@ -311,13 +311,6 @@ const StatefulPressable = (props: PressableProps) => {
         pressableEvent
       );
     },
-    onTouchesUp: () => {
-      if (Platform.OS === 'android' && !isScreenReaderEnabled) {
-        // Prevents potential soft-locks
-        stateMachine.reset();
-        handleFinalize();
-      }
-    },
     onTouchesCancel: (event) => {
       const pressableEvent = gestureTouchToPressableEvent(event);
       stateMachine.reset();
@@ -402,13 +395,9 @@ const StatefulPressable = (props: PressableProps) => {
         event.canceled ? StateMachineEvent.CANCEL : StateMachineEvent.FINALIZE
       );
 
-      // On iOS the button's cancel can land before the long press's touch
-      // cancel, or without one, so deliver the press-out here
-      if (
-        Platform.OS === 'ios' &&
-        event.canceled &&
-        isCurrentlyPressed.current
-      ) {
+      // The button's cancel can land before the long press's touch cancel,
+      // or without one, so deliver the press-out here
+      if (event.canceled && isCurrentlyPressed.current) {
         handlePressOut(
           pressInEventRef.current ??
             viewCenterToPressableEvent(dimensions.current),