internal/core/adt: fix some regressions

- Mark Evaluating before reprocessing Partial
This avoids a stack overflow.

- Don't finalize too early
It is important to not finalize nodes too early, as
this may result in insertions being ignored. In the
old implementation these bugs were missed as it
did a lot of extraneous recomputation.

- Fix "Finalized" forcing of disjunctions
When expanding disjunctions, only the last in a
sequence should be marked as finalized. The logic
here was flawed and would also tag the final
disjuncts of mid-stream subdisjunctions as final.

- As Resolve no longer finalizes, the cue API now
needs to finalize things itself.

- Ensure ToData does not leave dangling state
The state should always be Finalized, but just
in case.

Fixes #633

Change-Id: Ia6bd0b3bebb25c9033a30d3513b26b96454d0b91
Reviewed-on: https://cue-review.googlesource.com/c/cue/+/8141
Reviewed-by: CUE cueckoo <cueckoo@gmail.com>
Reviewed-by: Paul Jolly <paul@myitcv.org.uk>
Reviewed-by: Marcel van Lohuizen <mpvl@golang.org>

cue/testdata/builtins/closed.txtar

@@ -6,6 +6,18 @@ a: close({
 b: a & { x: int } // err
 c: a & { a: c: int } // okay (non-recursive close)
 
+inDisjunctions: {
+    x: [string]: #Def
+    #Def: [string]: {
+        a: b: true
+        let X = a
+        close({uint: a: b: X.b}) | close({string: a: b: true})
+    }
+    x: socket: string: {}
+    x: syslog: x.socket
+    x: syslog: xxx: {}
+}
+
 -- out/eval --
 Errors:
 b: field `x` not allowed:
@@ -39,6 +51,73 @@ Result:
       c: (int){ int }
     }
   }
+  inDisjunctions: (struct){
+    x: (struct){
+      socket: (#struct){
+        string: (struct){ |((#struct){
+            a: (#struct){
+              b: (bool){ true }
+            }
+            uint: (#struct){
+              a: (#struct){
+                b: (bool){ true }
+              }
+            }
+          }, (#struct){
+            a: (#struct){
+              b: (bool){ true }
+            }
+            string: (#struct){
+              a: (#struct){
+                b: (bool){ true }
+              }
+            }
+          }) }
+      }
+      syslog: (#struct){
+        string: (struct){ |((#struct){
+            a: (#struct){
+              b: (bool){ true }
+            }
+            uint: (#struct){
+              a: (#struct){
+                b: (bool){ true }
+              }
+            }
+          }, (#struct){
+            a: (#struct){
+              b: (bool){ true }
+            }
+            string: (#struct){
+              a: (#struct){
+                b: (bool){ true }
+              }
+            }
+          }) }
+        xxx: (struct){ |((#struct){
+            a: (#struct){
+              b: (bool){ true }
+            }
+            uint: (#struct){
+              a: (#struct){
+                b: (bool){ true }
+              }
+            }
+          }, (#struct){
+            a: (#struct){
+              b: (bool){ true }
+            }
+            string: (#struct){
+              a: (#struct){
+                b: (bool){ true }
+              }
+            }
+          }) }
+      }
+    }
+    #Def: (#struct){
+    }
+  }
 }
 -- out/compile --
 --- in.cue
@@ -56,4 +135,42 @@ Result:
       c: int
     }
   })
+  inDisjunctions: {
+    x: {
+      [string]: 〈1;#Def〉
+    }
+    #Def: {
+      [string]: {
+        a: {
+          b: true
+        }
+        (close({
+          uint: {
+            a: {
+              b: 〈3;let X〉.b
+            }
+          }
+        })|close({
+          string: {
+            a: {
+              b: true
+            }
+          }
+        }))
+      }
+    }
+    x: {
+      socket: {
+        string: {}
+      }
+    }
+    x: {
+      syslog: 〈1;x〉.socket
+    }
+    x: {
+      syslog: {
+        xxx: {}
+      }
+    }
+  }
 }