Add AutomaticAllocationScope to memref.alloca_scope

[shabalin]

Summary

This change adds AutomaticAllocationScope to the
memref.alloca_scope op. Additionally, it also clarifies
that alloca_scope is is conceptually a passthrough operation.

mlir/include/mlir/Dialect/MemRef/IR/MemRefOps.td

def MemRef_AllocaOp : AllocLikeOp<"alloca", AutomaticAllocationScopeResource> {
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // AllocaScopeOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_AllocaScopeOp : MemRef_Op<"alloca_scope", 
-      [DeclareOpInterfaceMethods<RegionBranchOpInterface>,
+      [AutomaticAllocationScope,
+       DeclareOpInterfaceMethods<RegionBranchOpInterface>,
        SingleBlockImplicitTerminator<"AllocaScopeReturnOp">,
        RecursiveSideEffects,
        NoRegionArguments]> {
   let summary = "explicitly delimited scope for stack allocation";
   let description = [{
     The `memref.alloca_scope` operation represents an explicitly-delimited
     scope for the alloca allocations. Any `memref.alloca` operations that are
     used within this scope are going to be cleaned up automatically once
     the control-flow exits the nested region. For example:
 
     ```mlir
     memref.alloca_scope {
       %myalloca = memref.alloca(): memref<4x3xf32>
       ...
     }
     ```
 
     Here, `%myalloca` memref is valid within the explicitly delimited scope
-    and is automatically deallocated at the end of the given region.
+    and is automatically deallocated at the end of the given region. Conceptually,
+    `memref.alloca_scope` is a passthrough operation with 
+    `AutomaticAllocationScope` that spans the body of the region within the operation. 
 
     `memref.alloca_scope` may also return results that are defined in the nested
     region. To return a value, one should use `memref.alloca_scope.return`
     operation:
 
     ```mlir
     %result = memref.alloca_scope {
       ...