[mlir][sparse] updated our sparse dialect doc with some recent changes

[aartbik]

Summary

The init and tensor ops are renamed (and one moved to another dialect).

[aartbik]

fixed another issue in doc

mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorOps.td

def SparseTensor_LexInsertOp : SparseTensor_Op<"lex_insert", []>,
     Arguments<(ins AnyTensor:$tensor,
                StridedMemRefRankOf<[Index], [1]>:$indices,
                AnyType:$value)> {
   string summary = "Inserts a value into given sparse tensor in lexicographical index order";
   string description = [{
     Inserts the given value at given indices into the underlying sparse
     storage format of the given tensor with the given indices. This
     operation can only be applied when a tensor materializes unintialized
-    with an `init` operation, the insertions occur in strict lexicographical
-    index order, and the final tensor is constructed with a `tensor`
-    operation that has the `hasInserts` attribute set.
+    with an `bufferization.alloc_tensor` operation, the insertions occur in
+    strict lexicographical index order, and the final tensor is constructed
+    with a `load` operation that has the `hasInserts` attribute set.
 
     Note that this operation is "impure" in the sense that its behavior
     is solely defined by side-effects and not SSA values. The semantics
     may be refined over time as our sparse abstractions evolve.
 
     ```mlir
     sparse_tensor.lex_insert %tensor, %indices, %val
       : tensor<1024x1024xf64, #CSR>, memref<?xindex>, f64
def SparseTensor_LoadOp : SparseTensor_Op<"load", [SameOperandsAndResultType]>,
   let hasVerifier = 1;
 }
 
 def SparseTensor_ReleaseOp : SparseTensor_Op<"release", []>,
     Arguments<(ins AnyTensor:$tensor)> {
   string summary = "Releases underlying sparse storage format of given tensor";
   string description = [{
     Releases the underlying sparse storage format for a tensor that
-    materialized earlier through a `new` operator, `init` operator, or a
-    `convert` operator with an annotated tensor type as destination (unless
-    that convert is folded away since the source and destination types were
-    identical). This operation should only be called once for any materialized
-    tensor.  Also, after this operation, any subsequent `memref` querying
-    operation on the tensor returns undefined results.
+    materialized earlier through a `new` operation, a `convert` operation
+    with annotated destination tensor type (unless the convert is folded
+    away), or a `bufferization.alloc_tensor` operation. The release operation
+    should only be called once for any materialized tensor. After this
+    operation, any subsequent `memref` querying operation on the tensor
+    returns undefined results.
 
     Note that this operation is "impure" in the sense that its behavior
     is solely defined by side-effects and not SSA values. The semantics
     may be refined over time as our sparse abstractions evolve.
 
     Example:
 
     ```mlir