[mlir][sparse] Updating STEA documentation examples to use "lvlTypes"

[wrengr]

Summary

Followup to D150330.

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

- Level-type for each level of a tensor type:
       and/or non-ordered (coordinates may appear unsorted).
         - **-nu** : not unique
         - **-no** : not ordered
       Currently, these suffixes (if present) must appear in this order.
       In the future, we may introduce additional level-types and
       properties, and split up how the level-format and properties are
       specified rather than using this suffix mechanism.
 
-      TODO: This field is called "dimLevelType" for historical reasons,
-      even though the types are per-level rather than per-dimension.
-      (This will be corrected in an upcoming change that completely
-      overhauls the syntax of this attribute.)
-
     - An optional permutation which maps (higher-ordering)-coordinates
       to level-coordinates; defaulting to the identity permutation.
       For example, given a 2-d tensor with the default higher-ordering,
       `(i, j) -> (i, j)` specifies row-wise storage and `(i, j) ->
       (j, i)` specifies column-wise storage.
 
       TODO: this field is called "dimOrdering" for historical reasons,
       even though it actually operates on level-coordinates rather than
let description = [{
     - An optional array of `SparseTensorDimSliceAttr`, which specifies
       how the sparse tensor is partitioned on each dimension.
 
     Examples:
 
     ```mlir
     // Sparse vector.
     #SparseVector = #sparse_tensor.encoding<{
-      dimLevelType = [ "compressed" ]
+      lvlTypes = [ "compressed" ]
     }>
     ... tensor<?xf32, #SparseVector> ...
 
     // Sorted Coordinate Scheme.
     #SortedCOO = #sparse_tensor.encoding<{
-      dimLevelType = [ "compressed-nu", "singleton" ]
+      lvlTypes = [ "compressed-nu", "singleton" ]
     }>
     ... tensor<?x?xf64, #SortedCOO> ...
 
     // Doubly compressed sparse column storage with specific bitwidths.
     #DCSC = #sparse_tensor.encoding<{
-      dimLevelType = [ "compressed", "compressed" ],
+      lvlTypes = [ "compressed", "compressed" ],
       dimOrdering = affine_map<(i, j) -> (j, i)>,
       posWidth = 32,
       crdWidth = 8
     }>
     ... tensor<8x8xf64, #DCSC> ...
 
     // Block sparse row storage (2x3 blocks).
     #BCSR = #sparse_tensor.encoding<{
-      dimLevelType = [ "compressed", "compressed", "dense", "dense" ],
+      lvlTypes = [ "compressed", "compressed", "dense", "dense" ],
       dimOrdering  = affine_map<(ii, jj, i, j) -> (ii, jj, i, j)>,
       higherOrdering = affine_map<(i, j) -> (i floordiv 2, j floordiv 3, i mod 2, j mod 3)>
     }>
     ... tensor<20x30xf32, #BCSR> ...
 
     // ELL storage (4 jagged diagonals, i.e., at most 4 nonzeros per row).
     #ELL = #sparse_tensor.encoding<{
-      dimLevelType = [ "dense", "dense", "compressed" ],
+      lvlTypes = [ "dense", "dense", "compressed" ],
       dimOrdering  = affine_map<(ii, i, j) -> (ii, i, j)>,
       higherOrdering = affine_map<(i, j)[c] -> (c * 4 * i, i, j)>
     }>
     ... tensor<?x?xf64, #ELL> ...
 
     // CSR slice (offset = 0, size = 4, stride = 1 on the first dimension;
     // offset = 0, size = 8, and a dynamic stride on the second dimension).
     #CSR_SLICE = #sparse_tensor.encoding<{
-      dimLevelType = [ "dense", "compressed" ],
+      lvlTypes = [ "dense", "compressed" ],
       slice = [ (0, 4, 1), (0, 8, ?) ]
     }>
     ... tensor<?x?xf64, #CSC_SLICE> ...
 
     ```
   }];
 
   // Data in sparse tensor encoding.