Fix Android nested carousel scrolling (#35656)

### Description of Change

Fixes Android touch arbitration for RecyclerView-backed MAUI items
controls when nested inside a perpendicular parent scroll container.

A horizontal `CarouselView` or `CollectionView` inside a vertical
`ScrollView` now releases vertical gestures to the nearest scrollable
parent instead of continuing to hold the gesture in the RecyclerView.
Own-axis gestures are still handled by the RecyclerView, and existing
disabled `ItemsView` behavior plus `CarouselView.IsSwipeEnabled`
behavior are preserved.

Adds an Android Appium regression page and test for the nested
`CarouselView` scenario. The test verifies that vertical scrolling from
inside the carousel works before and after a separate horizontal scroll
gesture.

### Issues Fixed

Fixes #7814

---------

Author: AdamEssenmacher

src/Controls/src/Core/Handlers/Items/Android/MauiRecyclerView.cs

@@ -39,6 +39,8 @@ public class MauiRecyclerView<TItemsView, TAdapter, TItemsViewSource> : Recycler
 		EmptyViewAdapter _emptyViewAdapter;
 		readonly DataChangeObserver _emptyCollectionObserver;
 		readonly DataChangeObserver _itemsUpdateScrollObserver;
+		readonly Func<MotionEvent, bool> _dispatchTouchEventToRecyclerView;
+		ParentScrollGestureDispatcher _parentScrollGestureDispatcher;
 
 		ScrollBarVisibility _defaultHorizontalScrollVisibility = ScrollBarVisibility.Default;
 		ScrollBarVisibility _defaultVerticalScrollVisibility = ScrollBarVisibility.Default;
@@ -60,6 +62,8 @@ public MauiRecyclerView(Context context, Func<IItemsLayout> getItemsLayout, Func
 
 			_emptyCollectionObserver = new DataChangeObserver(UpdateEmptyViewVisibility);
 			_itemsUpdateScrollObserver = new DataChangeObserver(AdjustScrollForItemUpdate);
+			_dispatchTouchEventToRecyclerView = DispatchTouchEventToRecyclerView;
+			_parentScrollGestureDispatcher = new ParentScrollGestureDispatcher(this);
 		}
 
 		protected override void OnAttachedToWindow()
@@ -624,6 +628,23 @@ public override bool OnTouchEvent(MotionEvent e)
 			return base.OnTouchEvent(e);
 		}
 
+		bool DispatchTouchEventToRecyclerView(MotionEvent e) => base.DispatchTouchEvent(e);
+
+		public override bool DispatchTouchEvent(MotionEvent e)
+		{
+			if (ItemsView?.IsEnabled == false && !ItemsView.IsExplicitlyEnabled)
+			{
+				return base.DispatchTouchEvent(e);
+			}
+
+			if (_parentScrollGestureDispatcher?.TryDispatchToParent(e, _dispatchTouchEventToRecyclerView, out var handled) == true)
+			{
+				return handled;
+			}
+
+			return base.DispatchTouchEvent(e);
+		}
+
 		public override bool OnInterceptTouchEvent(MotionEvent e)
 		{
 			// If ItemsView is disabled, intercept all touch events to prevent interactions.
@@ -653,6 +674,12 @@ protected override void OnLayout(bool changed, int l, int t, int r, int b)
 
 		protected override void Dispose(bool disposing)
 		{
+			if (disposing)
+			{
+				_parentScrollGestureDispatcher?.Dispose();
+				_parentScrollGestureDispatcher = null;
+			}
+
 			base.Dispose(disposing);
 			if (disposing)
 			{
@@ -662,6 +689,236 @@ protected override void Dispose(bool disposing)
 
 		internal ScrollHelper ScrollHelper => _scrollHelper ??= new ScrollHelper(this);
 
+		bool CanHandleOwnScrollDirection => this is not MauiCarouselRecyclerView carouselRecyclerView || carouselRecyclerView.IsSwipeEnabled;
+
+		class ParentScrollGestureDispatcher : IDisposable
+		{
+			readonly MauiRecyclerView<TItemsView, TAdapter, TItemsViewSource> _owner;
+			readonly int[] _targetLocation = new int[2];
+			MotionEvent _downEvent;
+			AView _parentScrollTarget;
+			float _touchStartX;
+			float _touchStartY;
+			int? _scaledTouchSlop;
+			GestureOwner _gestureOwner;
+
+			public ParentScrollGestureDispatcher(MauiRecyclerView<TItemsView, TAdapter, TItemsViewSource> owner)
+			{
+				_owner = owner;
+			}
+
+			public bool TryDispatchToParent(MotionEvent e, Func<MotionEvent, bool> dispatchToRecyclerView, out bool handled)
+			{
+				handled = false;
+
+				if (_gestureOwner == GestureOwner.Parent)
+				{
+					ForwardToParent(e);
+
+					if (IsTouchEnd(e))
+					{
+						Reset();
+					}
+
+					handled = true;
+					return true;
+				}
+
+				if (_gestureOwner == GestureOwner.RecyclerView)
+				{
+					if (IsTouchEnd(e))
+					{
+						Reset();
+					}
+
+					return false;
+				}
+
+				switch (e.ActionMasked)
+				{
+					case MotionEventActions.Down:
+						TrackDown(e);
+						return false;
+					case MotionEventActions.Move:
+						return TryStartForwardingToParent(e, dispatchToRecyclerView, out handled);
+					case MotionEventActions.Up:
+					case MotionEventActions.Cancel:
+						Reset();
+						return false;
+				}
+
+				return false;
+			}
+
+			public void Dispose()
+			{
+				Reset();
+			}
+
+			void TrackDown(MotionEvent e)
+			{
+				Reset();
+				_touchStartX = e.RawX;
+				_touchStartY = e.RawY;
+				_downEvent = MotionEvent.Obtain(e);
+				_owner.Parent?.RequestDisallowInterceptTouchEvent(false);
+			}
+
+			bool TryStartForwardingToParent(MotionEvent e, Func<MotionEvent, bool> dispatchToRecyclerView, out bool handled)
+			{
+				handled = false;
+
+				var layoutManager = _owner.GetLayoutManager();
+
+				if (layoutManager is null)
+				{
+					return false;
+				}
+
+				var canScrollHorizontally = layoutManager.CanScrollHorizontally();
+				var canScrollVertically = layoutManager.CanScrollVertically();
+
+				if (canScrollHorizontally == canScrollVertically)
+				{
+					return false;
+				}
+
+				var deltaX = Math.Abs(e.RawX - _touchStartX);
+				var deltaY = Math.Abs(e.RawY - _touchStartY);
+
+				if (deltaX < ScaledTouchSlop && deltaY < ScaledTouchSlop)
+				{
+					return false;
+				}
+
+				var movesInOwnScrollDirection = canScrollHorizontally
+					? deltaX >= deltaY
+					: deltaY >= deltaX;
+
+				if (movesInOwnScrollDirection)
+				{
+					_gestureOwner = GestureOwner.RecyclerView;
+					_owner.Parent?.RequestDisallowInterceptTouchEvent(_owner.CanHandleOwnScrollDirection);
+					return false;
+				}
+
+				var target = FindParentScrollTarget(e, canScrollHorizontally);
+
+				if (target is null)
+				{
+					return false;
+				}
+
+				_parentScrollTarget = target;
+				_gestureOwner = GestureOwner.Parent;
+				_owner.Parent?.RequestDisallowInterceptTouchEvent(false);
+				CancelRecyclerViewGesture(e, dispatchToRecyclerView);
+
+				if (_downEvent is not null)
+				{
+					ForwardToParent(_downEvent);
+				}
+
+				ForwardToParent(e);
+				handled = true;
+				return true;
+			}
+
+			AView FindParentScrollTarget(MotionEvent e, bool recyclerViewScrollsHorizontally)
+			{
+				var scrollDirection = recyclerViewScrollsHorizontally
+					? Math.Sign(_touchStartY - e.RawY)
+					: Math.Sign(_touchStartX - e.RawX);
+
+				if (scrollDirection == 0)
+				{
+					return null;
+				}
+
+				var parent = _owner.Parent;
+
+				while (parent is not null)
+				{
+					if (parent is AView view)
+					{
+						var canScroll = recyclerViewScrollsHorizontally
+							? view.CanScrollVertically(scrollDirection)
+							: view.CanScrollHorizontally(scrollDirection);
+
+						if (canScroll)
+						{
+							return view;
+						}
+					}
+
+					parent = parent.GetParent();
+				}
+
+				return null;
+			}
+
+			void CancelRecyclerViewGesture(MotionEvent e, Func<MotionEvent, bool> dispatchToRecyclerView)
+			{
+				var cancelEvent = MotionEvent.Obtain(e);
+				cancelEvent.Action = MotionEventActions.Cancel;
+
+				try
+				{
+					dispatchToRecyclerView(cancelEvent);
+				}
+				finally
+				{
+					cancelEvent.Recycle();
+				}
+			}
+
+			void ForwardToParent(MotionEvent source)
+			{
+				if (_parentScrollTarget is null)
+				{
+					return;
+				}
+
+				var targetEvent = MotionEvent.Obtain(source);
+				_parentScrollTarget.GetLocationOnScreen(_targetLocation);
+				targetEvent.SetLocation(source.RawX - _targetLocation[0], source.RawY - _targetLocation[1]);
+
+				try
+				{
+					_parentScrollTarget.OnTouchEvent(targetEvent);
+				}
+				finally
+				{
+					targetEvent.Recycle();
+				}
+			}
+
+			void Reset()
+			{
+				_owner.Parent?.RequestDisallowInterceptTouchEvent(false);
+				_parentScrollTarget = null;
+				_gestureOwner = GestureOwner.Undecided;
+
+				if (_downEvent is not null)
+				{
+					_downEvent.Recycle();
+					_downEvent = null;
+				}
+			}
+
+			int ScaledTouchSlop => _scaledTouchSlop ??= ViewConfiguration.Get(_owner.Context).ScaledTouchSlop;
+
+			static bool IsTouchEnd(MotionEvent e) =>
+				e.ActionMasked == MotionEventActions.Up || e.ActionMasked == MotionEventActions.Cancel;
+
+			enum GestureOwner
+			{
+				Undecided,
+				RecyclerView,
+				Parent
+			}
+		}
+
 		internal void UpdateEmptyViewVisibility()
 		{
 			if (ItemsViewAdapter == null)

src/Controls/src/Core/PublicAPI/net-android/PublicAPI.Unshipped.txt

@@ -9,6 +9,7 @@ override Microsoft.Maui.Controls.GraphicsView.OnBindingContextChanged() -> void
 ~static Microsoft.Maui.Controls.Handlers.Compatibility.ShellRenderer.DefaultTitleColor.get -> Microsoft.Maui.Graphics.Color
 ~static Microsoft.Maui.Controls.Handlers.Compatibility.ShellRenderer.DefaultUnselectedColor.get -> Microsoft.Maui.Graphics.Color
 override Microsoft.Maui.Controls.Shapes.Shape.OnPropertyChanged(string? propertyName = null) -> void
+~override Microsoft.Maui.Controls.Handlers.Items.MauiRecyclerView<TItemsView, TAdapter, TItemsViewSource>.DispatchTouchEvent(Android.Views.MotionEvent e) -> bool
 ~override Microsoft.Maui.Controls.Handlers.Items.MauiRecyclerView<TItemsView, TAdapter, TItemsViewSource>.OnInterceptTouchEvent(Android.Views.MotionEvent e) -> bool
 ~override Microsoft.Maui.Controls.Handlers.Items.MauiRecyclerView<TItemsView, TAdapter, TItemsViewSource>.OnTouchEvent(Android.Views.MotionEvent e) -> bool
 ~override Microsoft.Maui.Controls.Handlers.Items.RecyclerViewScrollListener<TItemsView, TItemsViewSource>.OnScrollStateChanged(AndroidX.RecyclerView.Widget.RecyclerView recyclerView, int newState) -> void