fix(#417): codex round 104 — default(T) operands inside literal chains

default(string) is null and contributes an empty string to a
concatenation, but the gap checker recognized only the literal null
keyword, so the fold broke at `default`. The gap now consumes a
word-bounded `default` followed by a balanced type-paren (reused
TryConsumeTypeParen), folded as an empty contribution.

Deliberately conservative on the type question: a text scan cannot
tell reference types (where default IS null — the actual evasion)
from value types (where it adds text), so ALL default(T) operands are
consumed; a value-type default in a fragment chain folds inexactly
and may refuse absurd-but-harmless code — the same fail-closed stance
as the cast/subtraction ambiguity. Untyped `default` cannot compile
inside a concatenation, so the paren form is required.

Mutation-verified: codex's exact default(string) form and a
default(string?)! variant each failed PostgresImagePin with the
composed-chain refusal; a variable merely NAMED defaultName in the
same gap position passed. Restored, rebuilt, all three
SchemaDocsTests green.

Author: mforce

tests/Cluckwork.Api.IntegrationTests/SchemaDocsTests.cs

@@ -499,6 +499,32 @@ static bool IsPlusGap(string t, int start, int end)
                             if (p < end && t[p] == '+') { p = SkipTrivia(t, p + 1); continue; }
                             return false;
                         }
+                        // default(T) likewise: for any reference type it IS
+                        // null and contributes nothing, which is the actual
+                        // evasion — and a text scan cannot tell reference
+                        // from value types, so ALL default(T) operands are
+                        // consumed as empty. Deliberately conservative: a
+                        // value-type default in a fragment chain folds
+                        // inexactly and may refuse absurd-but-harmless code
+                        // (same fail-closed stance as the cast/subtraction
+                        // ambiguity). Untyped `default` cannot compile in a
+                        // concatenation, so the paren form is required.
+                        if (p + 7 <= end && t.Substring(p, 7) == "default"
+                            && (p + 7 == end || !(char.IsLetterOrDigit(t[p + 7]) || t[p + 7] == '_')))
+                        {
+                            var d = SkipTrivia(t, p + 7);
+                            if (d < end && t[d] == '(')
+                            {
+                                var de = TryConsumeTypeParen(t, d);
+                                if (de > 0 && de <= end)
+                                {
+                                    p = SkipTrivia(t, de);
+                                    while (p < end && (t[p] == ')' || t[p] == '!')) p = SkipTrivia(t, p + 1);
+                                    if (p < end && t[p] == '+') { p = SkipTrivia(t, p + 1); continue; }
+                                }
+                            }
+                            return false;
+                        }
                         return false;
                     }
                     return true;