fix: treat non-null nullable defaults as real defaults

IsDefaultForType unwrapped Nullable<T> before comparing against the CLR
default, so a nullable options-group property initialized to 0 or false
(e.g. `int? Limit { get; set; } = 0`) had its default hidden from command
help, and AddGlobalOption<T?> discarded explicit CLR-default metadata that
GlobalOptionsSnapshot.GetValue would otherwise apply.

- Return false from IsDefaultForType for Nullable<T>: its default is null,
  so any non-null value is a deliberate default.
- Add regression tests for group-property help rendering and for runtime
  resolution of an explicit nullable global default.

Claude-Session: https://claude.ai/code/session_01AopmWBr1VknLrUqerBEWsB

Author: carldebilly

src/Repl.Core/ParsingOptions.cs

@@ -207,23 +207,31 @@ private static string BuildDuplicateGlobalOptionMessage(string name, Type? exist
 
 	internal static bool IsDefaultForType(object value, Type type)
 	{
-		var effectiveType = Nullable.GetUnderlyingType(type) ?? type;
-		if (effectiveType == typeof(bool))
+		// The default of a Nullable<T> is null, never a value: a nullable property or
+		// parameter initialized to 0 or false is a deliberate default that must be kept
+		// (rendered in help, applied at resolution), unlike the implicit default of the
+		// underlying non-nullable type.
+		if (Nullable.GetUnderlyingType(type) is not null)
+		{
+			return false;
+		}
+
+		if (type == typeof(bool))
 		{
 			return value is false;
 		}
 
-		if (effectiveType == typeof(int))
+		if (type == typeof(int))
 		{
 			return value is 0;
 		}
 
-		if (effectiveType == typeof(long))
+		if (type == typeof(long))
 		{
 			return value is 0L;
 		}
 
-		if (effectiveType == typeof(double))
+		if (type == typeof(double))
 		{
 			return value is 0.0d;
 		}

src/Repl.IntegrationTests/Given_GlobalOptionsAccessor.cs

@@ -81,6 +81,21 @@ public void When_GlobalOptionNotProvided_Then_DefaultIsReturned()
 		output.Text.Should().Contain("3000");
 	}
 
+	[TestMethod]
+	[Description("Regression guard: an explicit registration default equal to the CLR default of the underlying type (0), declared through a nullable type parameter, is preserved as metadata and applied when the option is omitted instead of the call-site fallback.")]
+	public void When_NullableGlobalOptionDeclaresUnderlyingClrDefault_Then_RegisteredDefaultWins()
+	{
+		var sut = ReplApp.Create();
+		sut.Options(o => o.Parsing.AddGlobalOption<int?>("port", defaultValue: 0));
+		sut.Map("show", (IGlobalOptionsAccessor globals) => $"port:{globals.GetValue<int>("port", 8080)}");
+
+		var output = ConsoleCaptureHelper.Capture(
+			() => sut.Run(["show", "--no-logo"]));
+
+		output.ExitCode.Should().Be(0);
+		output.Text.Should().Contain("port:0");
+	}
+
 	[TestMethod]
 	[Description("UseGlobalOptions<T> registers typed class accessible via DI.")]
 	public void When_UsingTypedGlobalOptions_Then_ClassIsPopulatedFromParsedValues()

src/Repl.IntegrationTests/Given_OptionsGroupBinding.cs

@@ -32,6 +32,19 @@ public class PositionalSearchOptions
 		public string Query { get; set; } = "";
 	}
 
+	[ReplOptionsGroup]
+	public class NullableDefaultsOptions
+	{
+		[ReplOption]
+		public int? Limit { get; set; } = 0;
+
+		[ReplOption]
+		public bool? Force { get; set; } = false;
+
+		[ReplOption]
+		public int Offset { get; set; }
+	}
+
 	[TestMethod]
 	[Description("Regression guard: verifies named options bind to options group properties.")]
 	public void When_UsingNamedOptionOnGroup_Then_PropertyBindsSuccessfully()
@@ -125,6 +138,22 @@ public void When_UsingTwoGroups_Then_BothBindIndependently()
 		output.Text.Should().Contain("json:20:5");
 	}
 
+	[TestMethod]
+	[Description("Regression guard: a nullable group property initialized to the CLR default of its underlying type (int? = 0, bool? = false) is a deliberate default the binder preserves, so command help must advertise it — while implicit defaults of non-nullable properties stay hidden.")]
+	public void When_NullableGroupPropertyInitializedToUnderlyingClrDefault_Then_HelpShowsDefault()
+	{
+		var sut = ReplApp.Create();
+		sut.Map("list", (NullableDefaultsOptions options) => "ok");
+
+		var output = ConsoleCaptureHelper.Capture(() => sut.Run(["list", "--help", "--no-logo"]));
+
+		output.ExitCode.Should().Be(0);
+		var lines = output.Text.Split('\n');
+		lines.Single(line => line.Contains("--limit")).Should().Contain("[default: 0]");
+		lines.Single(line => line.Contains("--force")).Should().Contain("[default: False]");
+		lines.Single(line => line.Contains("--offset")).Should().NotContain("[default:");
+	}
+
 	[TestMethod]
 	[Description("Regression guard: verifies token collision between group and regular parameter fails at registration.")]
 	public void When_GroupPropertyCollidesWithParam_Then_MapFails()