Implement new mutations with native core (#630)

* work on seperating tree struture from realdom

* intial update to new mutations

* handle height

* update to taffy 0.2

* add as_varient functions to OwnedAttributeValue

* make get node parent mut optionally return a parent

* work on upward pass

* add more code for parrellel passes

* make resolve passes public

* more work on parallel passes

* fix deadlock and add more tests

* move height into the tree instead of the realdom

* make passes exicute in parallel instead of executing invidual passes in parellel

* fix some warnings

* add up dependant test

* clean up examples

* work on intigrating state with passes

* update to new mutations

* work on implementing macro

* make the macro compile

* more progress on macro

* mark cloned nodes as dirty

* update persistant_iterator utility

* fix mask generation

* update tui with new mutations

* more progress updating tui

* some basic tui examples working

* don't push template nodes onto the stack

* update hover example

* update benchmark

* update more examples

* fix root node layout

* ignore out of bounds renders

* update color picker example

* update all events example

* update remaining examples

* update tests

* tests passing

* move persistant iterator test

* update examples

* fix gaps in layout

* fix formatting

* fix memory leak

packages/tui/benches/update.rs

@@ -73,7 +73,7 @@ fn Grid(cx: Scope<GridProps>) -> Element {
     let count = use_state(&cx, || 0);
     let counts = use_ref(&cx, || vec![0; size * size]);
 
-    let ctx: TuiContext = cx.consume_context().unwrap();
+    let ctx: &TuiContext = cx.consume_context().unwrap();
     if *count.get() + 1 >= (size * size) {
         ctx.quit();
     } else {
@@ -88,14 +88,14 @@ fn Grid(cx: Scope<GridProps>) -> Element {
         });
     }
 
-    cx.render(rsx! {
+    render! {
         div{
             width: "100%",
             height: "100%",
             flex_direction: "column",
             (0..size).map(|x|
                     {
-                    cx.render(rsx! {
+                    rsx! {
                         div{
                             width: "100%",
                             height: "100%",
@@ -104,7 +104,7 @@ fn Grid(cx: Scope<GridProps>) -> Element {
                                 {
                                     let alpha = y as f32*100.0/size as f32 + counts.read()[x*size + y] as f32;
                                     let key = format!("{}-{}", x, y);
-                                    cx.render(rsx! {
+                                    rsx! {
                                         Box{
                                             x: x,
                                             y: y,
@@ -112,15 +112,15 @@ fn Grid(cx: Scope<GridProps>) -> Element {
                                             hue: alpha,
                                             key: "{key}",
                                         }
-                                    })
+                                    }
                                 }
                             )
                         }
-                    })
+                    }
                 }
             )
         }
-    })
+    }
 }
 
 fn app3(cx: Scope) -> Element {