Reorganize project files & reduce public interface (#212)

Reorganizes files in the project to be more clearly and consistently
organized by visibility (whether the types within each file should be
internal to the package or public). Also reduces the public interface of
the module by moving some types to `internal` or `package`.

Note that `package` is specific to SPM, so the keyword cannot be used in
conjunction with CocoaPods. For this reason, a few of the types are
guarded with `#if COCOAPODS`. It's also worth noting that `ConnectNIO`
cannot be consumed via CocoaPods today because NIO does not support
CocoaPods. For this reason, the shared gRPC interfaces between `Connect`
and `ConnectNIO` don't need to be exposed to CocoaPods at all.
Additionally, [`package` requires Swift
5.9](https://github.com/apple/swift-evolution/blob/main/proposals/0386-package-access-modifier.md),
so the Swift package version has been updated as well.

New directory structure:

```
.
├── Examples
│   ├── ElizaCocoaPodsApp
│   ├── ElizaSharedSources
│   │   ├── AppSources
│   │   └── GeneratedSources
│   │       └── connectrpc
│   │           └── eliza
│   │               └── v1
│   └── ElizaSwiftPackageApp
│       └── ElizaSwiftPackageApp
├── Libraries
│   ├── Connect
│   │   ├── Internal
│   │   │   ├── Generated
│   │   │   │   └── grpc
│   │   │   │       └── status
│   │   │   │           └── v1
│   │   │   ├── Interceptors
│   │   │   ├── Locks
│   │   │   ├── Streaming
│   │   │   └── Unary
│   │   ├── PackageInternal
│   │   ├── Public
│   │   │   ├── Implementation
│   │   │   │   ├── Clients
│   │   │   │   ├── Codecs
│   │   │   │   └── Compression
│   │   │   └── Interfaces
│   │   │       ├── Interceptors
│   │   │       └── Streaming
│   │   │           ├── AsyncAwait
│   │   │           └── Callbacks
│   │   └── proto
│   │       └── grpc
│   │           └── status
│   │               └── v1
│   ├── ConnectMocks
│   └── ConnectNIO
│       ├── Internal
│       │   └── Extensions
│       └── Public
├── Plugins
│   ├── ConnectMocksPlugin
│   ├── ConnectPluginUtilities
│   └── ConnectSwiftPlugin
└── Tests
    ├── ConnectLibraryTests
    │   ├── ConnectConformance
    │   ├── ConnectMocksTests
    │   ├── ConnectTests
    │   ├── Generated
    │   │   ├── connectrpc
    │   │   │   └── conformance
    │   │   │       └── v1
    │   │   └── server
    │   │       └── v1
    │   └── TestResources
    └── ConnectPluginUtilitiesTests
```

Author: rebello95

.github/workflows/ci.yaml

@@ -44,6 +44,9 @@ jobs:
     runs-on: macos-13
     steps:
       - uses: actions/checkout@v4
+      - name: Select Xcode version
+        # https://github.com/actions/runner-images/blob/main/images/macos/macos-13-Readme.md#xcode
+        run: sudo xcode-select --switch /Applications/Xcode_15.0.app
       - uses: bufbuild/[email protected]
         with:
           github_token: ${{ github.token }}

.swiftlint.yml

@@ -4,7 +4,7 @@ included:
   - Plugins
   - Tests
 excluded:
-  - Libraries/Connect/Implementation/Generated
+  - Libraries/Connect/Internal/Generated
   - Tests/ConnectLibraryTests/Generated
 disabled_rules:
   - blanket_disable_command

Libraries/Connect/Implementation/Generated/grpc/status/v1/status.pb.swift renamed to Libraries/Connect/Internal/Generated/grpc/status/v1/status.pb.swift

@@ -16,26 +16,26 @@ import Foundation
 
 /// Class containing an internal lock which can be used to ensure thread-safe access to an
 /// underlying value. Conforms to `Sendable`, making it accessible from `@Sendable` closures.
-public final class Locked<T>: @unchecked Sendable {
+final class Locked<T>: @unchecked Sendable {
     private let lock = Lock()
     private var wrappedValue: T
 
     /// Thread-safe access to the underlying value.
-    public var value: T {
+    var value: T {
         get { self.lock.perform { self.wrappedValue } }
         set { self.lock.perform { self.wrappedValue = newValue } }
     }
 
     /// Perform an action with the underlying value, potentially updating that value.
     ///
     /// - parameter action: Closure to perform with the underlying value.
-    public func perform(action: @escaping (inout T) -> Void) {
+    func perform(action: @escaping (inout T) -> Void) {
         self.lock.perform {
             action(&self.wrappedValue)
         }
     }
 
-    public init(_ value: T) {
+    init(_ value: T) {
         self.wrappedValue = value
     }
 }