[Android] Fix Label with MaxLines truncating text in horizontal ScrollView (dotnet#34279)

> [!NOTE]
> Are you waiting for the changes in this PR to be merged?
> It would be very helpful if you could [test the resulting
artifacts](https://github.com/dotnet/maui/wiki/Testing-PR-Builds) from
this PR and let us know in a comment if this change resolves your issue.
Thank you!

### Root Cause

PR dotnet#33281 added a `GetDesiredSize()` override in
`LabelHandler.Android.cs` to fix issue dotnet#31782 (WordWrap labels reporting
full constraint width instead of actual text width). The fix computes
the longest wrapped line and returns that as the desired width.

This causes a regression when `MaxLines` is set on the label:
1. `GetDesiredSize()` is called at the full available width — text wraps
cleanly within MaxLines limit
2. The fix returns the shorter "longest line" width
3. The label is arranged at that narrower width
4. At the narrower width, the same text needs more lines — exceeding
MaxLines → text is clipped

### Description of Change

The `GetDesiredSize()` override now uses a double-measurement strategy:
1. **Entry guard**: Only applies the width-narrowing when `Ellipsize ==
null` (no active truncation).
2. **Compute candidate width**: Finds the widest rendered line as
before.
3. **Safety check** (only when `MaxLines` is explicitly set):
Re-measures the TextView at exactly the narrowed pixel width. If the
re-measurement shows the text would now exceed `MaxLines`, the original
full width is returned instead.
4. **Narrow when safe**: If the re-measurement confirms the same or
fewer lines, the narrowed width is returned — preserving the dotnet#31782
alignment fix even for labels with explicit `MaxLines`.

This avoids both regressions:
- Labels without `MaxLines` behave as before (alignment fix preserved,
no second measure).
- Labels with `MaxLines` that have line-count headroom also get the
alignment fix.

### Issues Fixed

Fixes dotnet#34120

### Tested platforms

- [x] Android
- [x] Windows
- [x] iOS
- [x] Mac

**Files Changed in this PR:**

| File | Change |
|------|--------|
| `src/Core/src/Handlers/Label/LabelHandler.Android.cs` |
Double-measurement fix (~20 lines) |
| `src/Controls/tests/TestCases.HostApp/Issues/Issue34120.cs` | New UI
test HostApp page |
| `src/Controls/tests/TestCases.Shared.Tests/Tests/Issues/Issue34120.cs`
| New NUnit UI test |

**Regression Reference:**
- Regressed by: PR dotnet#33281
- Introduced in: 10.0.40
- Works in: 10.0.30, 10.0.31
- Platform: Android only

### Screenshots

|Before|After|
|--|--|
|<img width="540" alt="image"
src="https://github.com/user-attachments/assets/4c365c06-6aa9-4471-9553-d46983ec66c7"
>|<img width="540" alt="image"
src="https://github.com/user-attachments/assets/d67723d9-fd79-4dcc-8451-f1537f8b3668"
>|

Author: Vignesh-SF3580

src/Controls/tests/TestCases.Android.Tests/snapshots/android/LabelNotTruncatedWithMaxLines.png

@@ -0,0 +1,81 @@
+namespace Maui.Controls.Sample.Issues;
+
+[Issue(IssueTracker.Github, 34120, "Label text truncated in ScrollView when MaxLines is set", PlatformAffected.Android)]
+public class Issue34120 : ContentPage
+{
+	// Reproduces the N3_Navigation layout: horizontal ScrollView with BindableLayout,
+	// 200×200 Border cards, Image (HeightRequest=120), and a Label with MaxLines=2.
+	record Issue34120MonkeyItem(string Name, string ImageUrl);
+
+	public Issue34120()
+	{
+		// Long names ("Golden Snub-nosed Monkey", "Tonkin Snub-nosed Monkey") are the ones
+		// that triggered truncation; "Baboon" is a short-name reference card.
+		var monkeys = new List<Issue34120MonkeyItem>
+		{
+			new("Golden Snub-nosed Monkey", "golden.jpg"),
+			new("Baboon",                   "papio.jpg"),
+			new("Tonkin Snub-nosed Monkey", "bluemonkey.jpg"),
+			new("Howler Monkey",            "alouatta.jpg"),
+			new("Squirrel Monkey",          "saimiri.jpg"),
+		};
+
+		var itemTemplate = new DataTemplate(() =>
+		{
+			var image = new Image
+			{
+				Aspect = Aspect.AspectFit,
+				HeightRequest = 120,
+				HorizontalOptions = LayoutOptions.Center,
+				VerticalOptions = LayoutOptions.Center,
+			};
+			image.SetBinding(Image.SourceProperty, "ImageUrl");
+
+			var nameLabel = new Label
+			{
+				FontSize = 14,
+				FontAttributes = FontAttributes.Bold,
+				BackgroundColor = Color.FromArgb("#AAFFFFFF"),
+				TextColor = Colors.Black,
+				Padding = new Thickness(4, 2),
+				HorizontalOptions = LayoutOptions.Center,
+				VerticalOptions = LayoutOptions.Center,
+				HorizontalTextAlignment = TextAlignment.Center,
+				LineBreakMode = LineBreakMode.WordWrap,
+				MaxLines = 2,
+			};
+			nameLabel.SetBinding(Label.TextProperty, "Name");
+			nameLabel.SetBinding(Label.AutomationIdProperty, "Name");
+
+			var card = new Border
+			{
+				Padding = new Thickness(10),
+				Stroke = Colors.LightGray,
+				StrokeThickness = 1,
+				WidthRequest = 200,
+				HeightRequest = 200,
+				BackgroundColor = Colors.White,
+				Content = new VerticalStackLayout
+				{
+					Spacing = 10,
+					Children = { image, nameLabel }
+				}
+			};
+			return card;
+		});
+
+		var horizontalStack = new HorizontalStackLayout
+		{
+			Spacing = 15,
+			Padding = new Thickness(5),
+		};
+		BindableLayout.SetItemTemplate(horizontalStack, itemTemplate);
+		BindableLayout.SetItemsSource(horizontalStack, monkeys);
+
+		Content = new ScrollView
+		{
+			Orientation = ScrollOrientation.Horizontal,
+			Content = horizontalStack,
+		};
+	}
+}

src/Controls/tests/TestCases.HostApp/Issues/Issue34120.cs

@@ -0,0 +1,21 @@
+using NUnit.Framework;
+using UITest.Appium;
+using UITest.Core;
+
+namespace Microsoft.Maui.TestCases.Tests.Issues;
+
+public class Issue34120 : _IssuesUITest
+{
+	public override string Issue => "Label text truncated in ScrollView when MaxLines is set";
+
+	public Issue34120(TestDevice device) : base(device) { }
+
+	[Test]
+	[Category(UITestCategories.Label)]
+	public void LabelNotTruncatedWithMaxLines()
+	{
+		// Wait for the page to load, then verify labels are not truncated.
+		App.WaitForElement("Golden Snub-nosed Monkey");
+		VerifyScreenshot();
+	}
+}

src/Controls/tests/TestCases.Mac.Tests/snapshots/mac/LabelNotTruncatedWithMaxLines.png

@@ -22,9 +22,12 @@ public override Size GetDesiredSize(double widthConstraint, double heightConstra
 
 			// Android TextView reports full available width instead of actual text width when
 			// text wraps to multiple lines, causing incorrect positioning for non-Fill alignments.
+			// We narrow the desired width to the widest rendered line, but only when that narrowing
+			// won't cause re-wrapping that exceeds MaxLines and truncates visible text.
 			if (VirtualView.HorizontalLayoutAlignment != Primitives.LayoutAlignment.Fill &&
 				PlatformView?.Layout is Layout layout &&
-				layout.LineCount > 1)
+				layout.LineCount > 1 &&
+				PlatformView.Ellipsize == null)
 			{
 				float maxLineWidth = 0;
 				for (int i = 0; i < layout.LineCount; i++)
@@ -38,7 +41,33 @@ public override Size GetDesiredSize(double widthConstraint, double heightConstra
 				{
 					var actualWidth = Context.FromPixels(maxLineWidth + PlatformView.PaddingLeft + PlatformView.PaddingRight);
 					if (actualWidth < size.Width)
+					{
+						// When MaxLines is constrained, verify that narrowing doesn't cause the text
+						// to re-wrap into more lines than MaxLines allows (which would truncate text).
+						// Re-measure at exactly the pixel width the view will be arranged at.
+						if (PlatformView.MaxLines != int.MaxValue)
+						{
+							var narrowedPx = (int)Context.ToPixels(actualWidth);
+
+							// AtMost mirrors how the layout pass constrains width, ensuring the
+							// re-measurement reflects the same wrapping behaviour the view will
+							// experience when arranged at actualWidth.
+							PlatformView.Measure(
+								MeasureSpecMode.AtMost.MakeMeasureSpec(narrowedPx),
+								MeasureSpecMode.Unspecified.MakeMeasureSpec(0));
+
+							// Fail-safe: if Layout is null after re-measurement we cannot verify
+							// that truncation won't occur, so return the original size.
+							var measuredLayout = PlatformView.Layout;
+
+							if (measuredLayout is null || measuredLayout.LineCount > PlatformView.MaxLines)
+							{
+								return size; // Narrowing causes truncation (or unverifiable); return original size
+							}
+						}
+
 						return new Size(actualWidth, size.Height);
+					}
 				}
 			}