fix mem leak on the usage of commandbuffercanvas in raster_cache

Runtime/flow/raster_cache.cs

             canvas.concat(transform);
             canvas.drawPicture(picture);
             canvas.flush();
+            canvas.dispose();
 
             return new RasterCacheResult(new Image(renderTexture), picture.paintBounds, devicePixelRatio);
         }

Runtime/ui/utils/basic_types/canvas_impl.cs

         RenderLayer _currentLayer;
         Rect _lastScissor;
 
+        public void dispose() {
+            if (this._currentLayer != null) {
+                this._clearLayer(this._currentLayer);
+                this._currentLayer.dispose();
+                this._currentLayer = null;
+                this._lastScissor = null;
+                this._layers.Clear();
+            }
+        }
+
         public PictureFlusher(RenderTexture renderTexture, float devicePixelRatio, MeshPool meshPool) {
             D.assert(renderTexture);
             D.assert(devicePixelRatio > 0);
                     case CmdDraw cmd:
                         this._setRenderTarget(cmdBuf, layer.rtID, ref toClear);
 
-                        if (cmd.layer != null) {
-                            if (cmd.layer.rtID == 0) {
+                        if (cmd.layerId != null) {
+                            if (cmd.layerId == 0) {
-                                cmdBuf.SetGlobalTexture(CmdDraw.texId, cmd.layer.rtID);
+                                cmdBuf.SetGlobalTexture(CmdDraw.texId, cmd.layerId.Value);
                             }
                         }
 
                         }
 
                         cmdBuf.DrawMesh(cmd.meshObj, CmdDraw.idMat, cmd.material, 0, cmd.pass, cmd.properties);
-                        if (cmd.layer != null) {
+                        if (cmd.layerId != null) {
                             cmdBuf.SetGlobalTexture(CmdDraw.texId, BuiltinRenderTextureType.None);
                         }
 

Runtime/ui/utils/basic_types/canvas_shader.cs

                 pass : pass,
                 material : mat,
                 properties : props,
-                layer : renderLayer
+                layerId : renderLayer.rtID
             );
         }
 
                 pass : pass,
                 material : mat,
                 properties : props,
-                layer : renderLayer
+                layerId : renderLayer.rtID
             );
         }
     }

Runtime/ui/utils/basic_types/command_buffer_canvas.cs

             this._recorder.reset();
             this._flusher.flush(picture);
         }
+
+        public void dispose() {
+            this._flusher.dispose();
+        }
     }
 }

Runtime/ui/utils/basic_types/render_cmd.cs

             public TextBlobMesh textMesh;
             public int pass;
             public MaterialPropertyBlock properties;
-            public RenderLayer layer;
+            public int? layerId;
             public Material material;
             public Image image; // just to keep a reference to avoid GC.
             public Mesh meshObj;
             }
 
             public static CmdDraw create(uiMeshMesh mesh = null, TextBlobMesh textMesh = null, int pass = 0,
-                MaterialPropertyBlock properties = null, RenderLayer layer = null, Material material = null,
+                MaterialPropertyBlock properties = null, int? layerId = null, Material material = null,
                 Image image = null, Mesh meshObj = null,
                 bool meshObjCreated = false) {
                 CmdDraw newCmd = ItemPoolManager.alloc<CmdDraw>();
                 newCmd.properties = properties;
-                newCmd.layer = layer;
+                newCmd.layerId = layerId;
                 newCmd.material = material;
                 newCmd.image = image;
                 newCmd.meshObj = meshObj;