Fix some typos in the MLIR documentation.

[matthiaskramm]

Summary

Fix minor typos in the tutorial and the "writing a pass" page.

[rriddle]

Thanks Matthias!

[matthiaskramm]

Thanks for the quick review, River! I don't have write access. Would you be able to commit this change?

mlir/docs/Tutorials/Toy/Ch-4.md

 ```c++
 /// Infer the output shape of the MulOp, this is required by the shape inference
 /// interface.
 void MulOp::inferShapes() { getResult().setType(getOperand(0).getType()); }
 ```
 
 At this point, each of the necessary Toy operations provide a mechanism by which
 to infer their output shapes. The ShapeInferencePass is a FunctionPass: it will
-runs on each Function in isolation. MLIR also supports general
+run on each Function in isolation. MLIR also supports general
 [OperationPasses](../../WritingAPass.md#operation-pass) that run on any isolated
 operation (i.e. other function-like operations), but here our module only
 contains functions, so there is no need to generalize to all operations.
 
 Implementing such a pass is done by creating a class inheriting from
 `mlir::FunctionPass` and overriding the `runOnFunction()` method:
 
 ```c++

mlir/docs/Tutorials/Toy/Ch-5.md

*   A [Conversion Target](../../DialectConversion.md#conversion-target)
     -   This is the formal specification of what operations or dialects are
         legal for the conversion. Operations that aren't legal will require
         rewrite patterns to perform
         [legalization](../../../getting_started/Glossary.md#legalization).
 
 *   A set of
     [Rewrite Patterns](../../DialectConversion.md#rewrite-pattern-specification)
 
-    -   These are the set of [patterns](../../QuickstartRewrites.md) used to
+    -   This is the set of [patterns](../../QuickstartRewrites.md) used to
         convert `illegal` operations into a set of zero or more `legal` ones.
 
 *   Optionally, a [Type Converter](../../DialectConversion.md#type-conversion).
 
     -   If provided, this is used to convert the types of block arguments. We
         won't be needing this for our conversion.
 
 ## Conversion Target

mlir/docs/Tutorials/Toy/Ch-6.md

 }
 ```
 
 ### Setting up a JIT
 
 Setting up a JIT to run the module containing the LLVM dialect can be done using
 the `mlir::ExecutionEngine` infrastructure. This is a utility wrapper around
 LLVM's JIT that accepts `.mlir` as input. The full code listing for setting up
-the JIT can be found in `Ch6/toy.cpp` in the `runJit()` function:
+the JIT can be found in `Ch6/toyc.cpp` in the `runJit()` function:
 
 ```c++
 int runJit(mlir::ModuleOp module) {
   // Initialize LLVM targets.
   llvm::InitializeNativeTarget();
   llvm::InitializeNativeTargetAsmPrinter();
 
   // An optimization pipeline to use within the execution engine.

mlir/docs/WritingAPass.md

 
 Given a preserved analysis set, the analysis returns true if it should truly be
 invalidated. This allows for more fine-tuned invalidation in cases where an
 analysis wasn't explicitly marked preserved, but may be preserved (or
 invalidated) based upon other properties such as analyses sets.
 
 ### Querying Analyses
 
-The base `OperationPass` class provide utilities for querying and preserving
+The base `OperationPass` class provides utilities for querying and preserving
 analyses for the current operation being processed.
 
 *   OperationPass automatically provides the following utilities for querying
     analyses:
     *   `getAnalysis<>`
         -   Get an analysis for the current operation, constructing it if
             necessary.
     *   `getCachedAnalysis<>`