See through parentheses when resolving ambient type references

FCS represents `of (FooArgs)` as SynType.Paren, so the by-name lookups
for a union case's payload record and for union- or record-typed
fields rejected declarations which were valid without the parentheses.
Strip optional parens before all three lookups.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: Smaug123

WoofWare.Myriad.Plugins/ArgParserGenerator.fs

@@ -895,14 +895,14 @@ module internal ArgParserGenerator =
                         | l -> List.ofSeq l
 
                 let ambientRecordMatch =
-                    match fieldType with
+                    match SynType.stripOptionalParen fieldType with
                     | SynType.LongIdent (SynLongIdent.SynLongIdent (id, _, _)) ->
                         let target = List.last(id).idText
                         ambientRecords |> List.tryFind (fun r -> r.Name.idText = target)
                     | _ -> None
 
                 let ambientUnionMatch =
-                    match fieldType with
+                    match SynType.stripOptionalParen fieldType with
                     | SynType.LongIdent (SynLongIdent.SynLongIdent (id, _, _)) ->
                         let target = List.last(id).idText
                         ambientUnions |> List.tryFind (fun u -> u.Name.idText = target)
@@ -1068,7 +1068,7 @@ module internal ArgParserGenerator =
                     match case.Fields with
                     | [ field ] ->
                         let payload =
-                            match field.Type with
+                            match SynType.stripOptionalParen field.Type with
                             | SynType.LongIdent (SynLongIdent.SynLongIdent (id, _, _)) ->
                                 let target = List.last(id).idText
                                 ambientRecords |> List.tryFind (fun r -> r.Name.idText = target)

WoofWare.Myriad.Plugins/Test/TestArgParserRejection.fs

@@ -541,6 +541,85 @@ type BadDu =
         |> shouldRejectWith
             "Case FooCase of [<ArgParser>] union BadDu must have exactly one field: a record holding that case's arguments."
 
+    [<Test>]
+    let ``Parenthesized type references are accepted wherever bare ones are`` () =
+        // FCS represents `of (FooArgs)` as SynType.Paren; the by-name lookups for a case's
+        // payload record, and for union- or record-typed fields, must see through it.
+        let modules =
+            generateFromSource
+                """namespace TestMe
+
+open WoofWare.Myriad.Plugins
+
+type FooArgs =
+    {
+        Foo : int
+    }
+
+type BarArgs =
+    {
+        Bar : int
+    }
+
+[<ArgParser>]
+type DuArgs =
+    | FooCase of (FooArgs)
+    | BarCase of BarArgs
+"""
+
+        List.length modules |> shouldEqual 2
+
+        let modules =
+            generateFromSource
+                """namespace TestMe
+
+open WoofWare.Myriad.Plugins
+
+type AutoMode =
+    {
+        Quiet : bool option
+    }
+
+type ManualMode =
+    {
+        Level : int
+    }
+
+type Mode =
+    | Auto of AutoMode
+    | Manual of ManualMode
+
+[<ArgParser>]
+type WithModeArgs =
+    {
+        Verbose : bool
+        Mode : (Mode)
+    }
+"""
+
+        List.length modules |> shouldEqual 2
+
+        let modules =
+            generateFromSource
+                """namespace TestMe
+
+open WoofWare.Myriad.Plugins
+
+type ChildRecord =
+    {
+        Thing : int
+    }
+
+[<ArgParser>]
+type ParentRecord =
+    {
+        Child : (ChildRecord)
+        AndAnother : bool
+    }
+"""
+
+        List.length modules |> shouldEqual 2
+
     [<Test>]
     let ``The motivating union of alternative argument sets generates successfully`` () =
         let modules =