[iOS][MAUI 10] CollectionView CanReorderItems causes jitter and repeated haptic feedback over variable-height rows

## Description

When `CanReorderItems="True"` is enabled on a `CollectionView`, dragging a shorter row over a taller row causes the taller row item to jitter or bounce.

On iOS, the same interaction also triggers a large amount of repeated tactile/haptic feedback while the dragged item is moving over the taller row.

Dragging a larger item over smaller items, or over items with equal height, works fine.

This is visible when the `CollectionView` contains variable-height rows, for example rows where a `Label` wraps onto multiple lines.

This has only been observed on iOS.

## Steps to Reproduce

1. Create a .NET MAUI 10 app.
2. Add a page with only a `CollectionView`.
3. Set `CanReorderItems="True"`.
4. Use a hardcoded `ObservableCollection` as the `ItemsSource`.
5. Use a simple item template with a single wrapping `Label`.
6. Include both short and long strings so the rows have different heights.
7. Run the app on iOS.
8. Drag a short row slowly over a taller row.

## Expected Behavior

The dragged row should move smoothly over rows of different heights.

The reorder target should remain stable while dragging.

Tactile/haptic feedback should not repeatedly fire while hovering over the same larger row.

## Actual Behavior

When dragging a smaller row over a larger row on iOS:

- The taller row item jitters or bounces.
- The target area appears unstable while the pointer/finger moves over the larger row.
- A large amount of repeated tactile/haptic feedback is triggered.

## Minimal Reproduction Page

The page below is intentionally minimal. It does not use `SwipeView`, nested row layout, app services, persistence, or dynamic data.

The visual structure is only:

`ContentPage` -> `CollectionView` -> `Label`

```xml

```

```csharp
using System.Collections.ObjectModel;

namespace MauiAppPlayground.Pages;

public partial class DragReorderPage : ContentPage
{
public DragReorderPage()
{
InitializeComponent();
BindingContext = this;
}

public ObservableCollection Items { get; } =
[
"Short row",
"A medium row for comparison",
"This row is deliberately long enough to wrap onto multiple lines on narrow and medium widths so the native reorder behavior can be tested with a taller item.",
"Tiny",
"Another long row with plain text only. There are no images, swipe views, nested layouts, gestures, or app services involved in this repro list.",
"One line",
"A final long item that should create a different height from the surrounding short rows when the list is reordered."
];
}
```

## Environment

- .NET SDK: `10.0.300`
- Microsoft.Maui.Controls versions observed:
- `10.0.70`
- `10.0.30`
- MAUI workload version: `10.0.300-manifests.e0989437`
- Project target frameworks:
- `net10.0-android`
- `net10.0-ios`
- `net10.0-maccatalyst`
- `net10.0-windows10.0.19041.0`
- Observed platform: iOS only
- iOS versions:
- `26.3.1 (a)`
- `18.7.9`
- IDE: Visual Studio 2026

## Notes

This was first noticed in a richer `GroupsPage` row template. The minimal page above exists to isolate whether the problem is in native `CollectionView` reorder behavior with mixed row heights, rather than in the richer row structure.

The issue appears related to dragging over rows whose measured height is larger than the dragged row height.

## Workaround

No good workaround is known.

Using fixed-height rows or preventing labels from wrapping will remove the jitter, but that removes the required UI behavior and does not address the native reorder instability with variable-height rows.

### Version with bug

10.0.70

### Is this a regression from previous behavior?

Not sure, did not test other versions

### Last version that worked well

_No response_

### Affected platforms

iOS

### Affected platform versions

_No response_

### Relevant log output

```shell

```

Start by running the minimal CollectionView reproduction with CanReorderItems enabled on iOS, using the wrapping Label and mixed-height strings described in the issue. Trace the iOS CollectionView reorder entry point while dragging a short row over a taller row. Done means variable-height rows reorder smoothly, the target remains stable, and repeated haptic feedback does not occur.

Written by the indexing model from the issue text.