Validate incoming OpenAPI docs using OpenAPIKit's built-in validation (#130)

Validate incoming OpenAPI docs using OpenAPIKit's built-in validation

### Motivation

When provided with an OpenAPI document that has recursion, the generator either crashes, or produces Swift code that doesn't compile. We should catch recursion earlier in the process, and emit a descriptive error.

### Modifications

This PR adds two validation steps:
- OpenAPIKit's `validate` method catches some structural issues in the OpenAPI doc.
- OpenAPIKit's `locallyDereferenced()` method is a great way to ensure no reference cycles appear in the document.

Catching reference cycles earlier in the process is great, as even if we generate the Swift code, it won't compile until we have some explicit support for recursive types (tracked by #70).

### Result

Now, when an OpenAPI document with recursion is provided, instead of crashing or producing non-compiling Swift code, it prints a descriptive error and returns a non-0 code.

### Test Plan

Tested manually on the CLI with purposefully malformed documents. But since this isn't our code, I don't want to add detailed tests of the validation details.


Reviewed by: simonjbeaumont

Builds:
     ✔︎ pull request validation (5.8) - Build finished. 
     ✔︎ pull request validation (5.9) - Build finished. 
     ✔︎ pull request validation (docc test) - Build finished. 
     ✔︎ pull request validation (integration test) - Build finished. 
     ✔︎ pull request validation (nightly) - Build finished. 
     ✔︎ pull request validation (soundness) - Build finished. 

#130

Author: czechboy0

Sources/_OpenAPIGeneratorCore/GeneratorPipeline.swift

@@ -122,7 +122,39 @@ func makeGeneratorPipeline(
                     diagnostics: diagnostics
                 )
             },
-            postTransitionHooks: []
+            postTransitionHooks: [
+                { doc in
+
+                    // Run OpenAPIKit's built-in validation.
+                    try doc.validate()
+
+                    // Validate that the document is dereferenceable, which
+                    // catches reference cycles, which we don't yet support.
+                    _ = try doc.locallyDereferenced()
+
+                    // Also explicitly dereference the parts of components
+                    // that the generator uses. `locallyDereferenced()` above
+                    // only dereferences paths/operations, but not components.
+                    let components = doc.components
+                    try components.schemas.forEach { schema in
+                        _ = try schema.value.dereferenced(in: components)
+                    }
+                    try components.parameters.forEach { schema in
+                        _ = try schema.value.dereferenced(in: components)
+                    }
+                    try components.headers.forEach { schema in
+                        _ = try schema.value.dereferenced(in: components)
+                    }
+                    try components.requestBodies.forEach { schema in
+                        _ = try schema.value.dereferenced(in: components)
+                    }
+                    try components.responses.forEach { schema in
+                        _ = try schema.value.dereferenced(in: components)
+                    }
+
+                    return doc
+                }
+            ]
         ),
         translateOpenAPIToStructuredSwiftStage: .init(
             preTransitionHooks: [],