[mlir][bufferize][doc] Fix documentation of return type of `to_memref`.

[ingomueller-net]

Summary

This is my very first contact with this dialect, so I am not very
confident with this commit, but it seems like the op returns a memref,
not a tensor, so that's what comment about the result type should say.

[mlir][bufferization][doc] Improve typesetting of inline code. Fix Typo.

[pifon2a]

Thanks, Ingo!

mlir/include/mlir/Dialect/Bufferization/IR/BufferizationOps.td

let description = [{
     can be used to control in-place bufferization decisions during One-Shot
     Bufferize: The bufferized result of a `bufferization.alloc_tensor` does not
     alias with any other buffer, so it can be used to resolve read-after-write
     conflicts that would have been introduced by the in-place bufferization of
     another op.
 
     The optional `memory_space` attribute specifies the memory space when
     bufferizing this op. The memory space is inferred from `copy` if specified.
-    If neigher `copy` nor `memory_space` is specified, the default memory space
+    If neither `copy` nor `memory_space` is specified, the default memory space
     is used during bufferization.
 
     Both dense and sparse tensor types are supported. The result of a
     `bufferization.alloc_tensor` is a tensor value that can be used like any
     other tensor value. In practice, it is often used as the "out" operand of
     another op. Sparse tensor allocations should always be used in a local
     construction operation and never escape the function boundary directly.
 
def Bufferization_ToTensorOp : Bufferization_Op<"to_tensor", [
     SameOperandsAndResultShape,
     SameOperandsAndResultElementType,
     TypesMatchWith<"result type matches tensor equivalent of 'memref'",
                    "memref", "result",
                    "memref::getTensorTypeFromMemRefType($_self)">
   ]> {
   let summary = "memref to tensor operation";
   let description = [{
-    Create a tensor from a memref, making an independent copy of the element
+    Create a tensor from a `memref`, making an independent copy of the element
     data. The result value is a tensor whose shape and element type match the
     memref operand.
 
-    The opposite of this op is to_memref. Together, these two ops are
+    The opposite of this op is `to_memref`. Together, these two ops are
     useful for source/target materializations when doing type conversions
     involving tensors and memrefs.
 
     Example:
 
     ```mlir
     // Produces a value of tensor<4x?xf32> type.
     %12 = bufferization.to_tensor %10 : memref<4x?xf32, #layout, memspace0>
TypesMatchWith<"type of 'tensor' is the tensor equivalent of 'memref'",
                    "memref", "tensor",
                    "memref::getTensorTypeFromMemRefType($_self)">
   ]> {
   let summary = "tensor to memref cast operation";
   let description = [{
     Casts a tensor to a memref.
 
     ```mlir
-    // Result type is tensor<4x?xf32>
+    // Result type is memref<4x?xf32, #map0, 42>
     %12 = bufferization.to_memref %10 : memref<4x?xf32, #map0, 42>
     ```
 
-    Note, that mutating the result of the to_memref operation leads to
+    Note, that mutating the result of the `to_memref` operation leads to
     undefined behavior.
 
     This operation is a specialized variant of the built-in
-    unrealized_conversion_cast and is intended for use in the context of
+    `unrealized_conversion_cast` and is intended for use in the context of
     gradual bufferization.
   }];
 
   let arguments = (ins AnyTensor:$tensor);
   let results = (outs AnyRankedOrUnrankedMemRef:$memref);
 
   let extraClassDeclaration = [{
     //===------------------------------------------------------------------===//