add-target breaks resulting package when target name is not valid Swift identifier (#7764)

Executing `swift package add-target my-target --type executable` breaks
the updated package because the executable target name is not a valid
Swift identifier.

### Motivation:
After executing `swift package add-target my-target --type executable`,
I expect the generated stub to not break the modified package. However,
in this case, the resulting stub file would contain invalid Swift code:
```swift
@main
struct my-targetMain {
    static func main() {
        print("Hello, world")
    }
}
```
The same issue applies to `macro` and `test` target types. It's also
important to note that `dash case` is quite often used for target names,
like e.g. in
[swift-argument-parser](https://github.com/apple/swift-argument-parser/blob/main/Package.swift#L65-L68).

Additionaly, when `AddTarget` is consumed via an API (as opposed to the
CLI), the following parsing error is thrown into `stdout`:

<img width="796" alt="Screenshot 2024-07-08 at 08 40 51"
src="https://github.com/swiftlang/swift-package-manager/assets/1008612/c2696127-3e34-47a2-aa60-a843cfb64bda">

### Modifications:

I believe there are at least two ways to solve this issue:
1. Use a predefined type name in the generated stub, such as `struct
ExampleMain`, so it doesn't depend on the target name.
2. Introduce a sanitizer function to ensure that the target name is
always a valid Swift identifier. For example, a function that would
convert "$my-target-name%" into "myTargetName".

For the sake of simplicity, I opted for approach `#1` in the proposed
PR. However, if it's necessary to preserve target names in the generated
stubs, we can certainly go with approach `#2`.

### Result:

`swift package add-target my-target --type executable`
```swift
@main
struct ExampleMain {
    static func main() {
        print("Hello, world")
    }
}
```

Author: dmhts

Sources/PackageModelSyntax/AddTarget.swift

@@ -217,10 +217,10 @@ public struct AddTarget {
         case .macro:
             """
             \(imports)
-            struct \(raw: target.name): Macro {
+            struct \(raw: target.sanitizedName): Macro {
                 /// TODO: Implement one or more of the protocols that inherit
                 /// from Macro. The appropriate macro protocol is determined
-                /// by the "macro" declaration that \(raw: target.name) implements.
+                /// by the "macro" declaration that \(raw: target.sanitizedName) implements.
                 /// Examples include:
                 ///     @freestanding(expression) macro --> ExpressionMacro
                 ///     @attached(member) macro         --> MemberMacro
@@ -238,8 +238,8 @@ public struct AddTarget {
             case .xctest:
                 """
                 \(imports)
-                class \(raw: target.name): XCTestCase {
-                    func test\(raw: target.name)() {
+                class \(raw: target.sanitizedName)Tests: XCTestCase {
+                    func test\(raw: target.sanitizedName)() {
                         XCTAssertEqual(42, 17 + 25)
                     }
                 }
@@ -249,8 +249,8 @@ public struct AddTarget {
                 """
                 \(imports)
                 @Suite
-                struct \(raw: target.name)Tests {
-                    @Test("\(raw: target.name) tests")
+                struct \(raw: target.sanitizedName)Tests {
+                    @Test("\(raw: target.sanitizedName) tests")
                     func example() {
                         #expect(42 == 17 + 25)
                     }
@@ -267,7 +267,7 @@ public struct AddTarget {
             """
             \(imports)
             @main
-            struct \(raw: target.name)Main {
+            struct \(raw: target.sanitizedName)Main {
                 static func main() {
                     print("Hello, world")
                 }
@@ -296,9 +296,9 @@ public struct AddTarget {
             import SwiftCompilerPlugin
 
             @main
-            struct \(raw: target.name)Macros: CompilerPlugin {
+            struct \(raw: target.sanitizedName)Macros: CompilerPlugin {
                 let providingMacros: [Macro.Type] = [
-                    \(raw: target.name).self,
+                    \(raw: target.sanitizedName).self,
                 ]
             }
             """
@@ -364,3 +364,15 @@ fileprivate extension PackageDependency {
         )
     }
 }
+
+fileprivate extension TargetDescription {
+    var sanitizedName: String {
+        name
+            .spm_mangledToC99ExtendedIdentifier()
+            .localizedFirstWordCapitalized()
+    }
+}
+
+fileprivate extension String {
+    func localizedFirstWordCapitalized() -> String { prefix(1).localizedCapitalized + dropFirst() }
+}

Tests/PackageModelSyntaxTests/ManifestEditTests.swift

@@ -468,7 +468,7 @@ class ManifestEditTests: XCTestCase {
                     // These are the targets
                     .target(name: "MyLib"),
                     .executableTarget(
-                        name: "MyProgram",
+                        name: "MyProgram target-name",
                         dependencies: [
                             .product(name: "SwiftSyntax", package: "swift-syntax"),
                             .target(name: "TargetLib"),
@@ -479,13 +479,13 @@ class ManifestEditTests: XCTestCase {
             )
             """,
             expectedAuxiliarySources: [
-                RelativePath("Sources/MyProgram/MyProgram.swift") : """
+                RelativePath("Sources/MyProgram target-name/MyProgram target-name.swift") : """
                 import MyLib
                 import SwiftSyntax
                 import TargetLib
 
                 @main
-                struct MyProgramMain {
+                struct MyProgram_target_nameMain {
                     static func main() {
                         print("Hello, world")
                     }
@@ -494,7 +494,7 @@ class ManifestEditTests: XCTestCase {
             ]) { manifest in
             try AddTarget.addTarget(
                 TargetDescription(
-                    name: "MyProgram",
+                    name: "MyProgram target-name",
                     dependencies: [
                         .product(name: "SwiftSyntax", package: "swift-syntax"),
                         .target(name: "TargetLib", condition: nil),
@@ -528,7 +528,7 @@ class ManifestEditTests: XCTestCase {
                 ],
                 targets: [
                     .macro(
-                        name: "MyMacro",
+                        name: "MyMacro target-name",
                         dependencies: [
                             .product(name: "SwiftCompilerPlugin", package: "swift-syntax"),
                             .product(name: "SwiftSyntaxMacros", package: "swift-syntax")
@@ -538,33 +538,33 @@ class ManifestEditTests: XCTestCase {
             )
             """,
             expectedAuxiliarySources: [
-                RelativePath("Sources/MyMacro/MyMacro.swift") : """
+                RelativePath("Sources/MyMacro target-name/MyMacro target-name.swift") : """
                 import SwiftCompilerPlugin
                 import SwiftSyntaxMacros
 
-                struct MyMacro: Macro {
+                struct MyMacro_target_name: Macro {
                     /// TODO: Implement one or more of the protocols that inherit
                     /// from Macro. The appropriate macro protocol is determined
-                    /// by the "macro" declaration that MyMacro implements.
+                    /// by the "macro" declaration that MyMacro_target_name implements.
                     /// Examples include:
                     ///     @freestanding(expression) macro --> ExpressionMacro
                     ///     @attached(member) macro         --> MemberMacro
                 }
                 """,
-                RelativePath("Sources/MyMacro/ProvidedMacros.swift") : """
+                RelativePath("Sources/MyMacro target-name/ProvidedMacros.swift") : """
                 import SwiftCompilerPlugin
 
                 @main
-                struct MyMacroMacros: CompilerPlugin {
+                struct MyMacro_target_nameMacros: CompilerPlugin {
                     let providingMacros: [Macro.Type] = [
-                        MyMacro.self,
+                        MyMacro_target_name.self,
                     ]
                 }
                 """
                 ]
         ) { manifest in
             try AddTarget.addTarget(
-                TargetDescription(name: "MyMacro", type: .macro),
+                TargetDescription(name: "MyMacro target-name", type: .macro),
                 to: manifest
             )
         }
@@ -582,17 +582,17 @@ class ManifestEditTests: XCTestCase {
             let package = Package(
                 name: "packages",
                 targets: [
-                    .testTarget(name: "MyTest"),
+                    .testTarget(name: "MyTest target-name"),
                 ]
             )
             """,
             expectedAuxiliarySources: [
-                RelativePath("Tests/MyTest/MyTest.swift") : """
+                RelativePath("Tests/MyTest target-name/MyTest target-name.swift") : """
                 import Testing
 
                 @Suite
-                struct MyTestTests {
-                    @Test("MyTest tests")
+                struct MyTest_target_nameTests {
+                    @Test("MyTest_target_name tests")
                     func example() {
                         #expect(42 == 17 + 25)
                     }
@@ -601,7 +601,7 @@ class ManifestEditTests: XCTestCase {
             ]) { manifest in
             try AddTarget.addTarget(
                 TargetDescription(
-                    name: "MyTest",
+                    name: "MyTest target-name",
                     type: .test
                 ),
                 to: manifest,