Refactor to use parent/child notation

In `normalized` we process the threshold policy as well as its child
threshold policy and we shadow `subs` - this is all very confusing. Add
parent/child terminology and a couple extra local variables in an
attempt to make the code more clear.

Refactor only, no logic changes.

Author: tcharding

src/policy/semantic.rs

@@ -422,18 +422,27 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                 let n = subs.len() - unsatisfied_count - trivial_count; // remove all true/false
                 let m = k.checked_sub(trivial_count).unwrap_or(0); // satisfy all trivial
 
-                let is_and = m == n;
-                let is_or = m == 1;
+                let parent_is_and = m == n; // (n, n)-thresh is an AND
+                let parent_is_or = m == 1; // (1, n)-thresh is an OR
 
                 for sub in subs {
                     match sub.as_ref() {
                         Policy::Trivial | Policy::Unsatisfiable => {}
                         Policy::Threshold(ref k, ref subs) => {
-                            match (is_and, is_or) {
-                                (true, true) => ret_subs.push(Arc::clone(&sub)), // m = n = 1, thresh(1,X) type thing.
-                                (true, false) if *k == subs.len() => ret_subs.extend(subs.to_vec()), // and case
-                                (false, true) if *k == 1 => ret_subs.extend(subs.to_vec()), // or case
-                                _ => ret_subs.push(Arc::clone(&sub)),
+                            let child_is_and = *k == subs.len();
+                            let child_is_or = *k == 1;
+
+                            if parent_is_and && parent_is_or {
+                                // m = n = 1, child must be the non-trivial, non-unsatisfiable node.
+                                ret_subs.push(Arc::clone(&sub));
+                            } else if parent_is_and && child_is_and {
+                                // If both parent and child are ANDs we can flatten them.
+                                subs.iter().for_each(|sub| ret_subs.push(Arc::clone(sub)));
+                            } else if parent_is_or && child_is_or {
+                                // If both parent and child are ORs we can flatten them.
+                                subs.iter().for_each(|sub| ret_subs.push(Arc::clone(sub)));
+                            } else {
+                                ret_subs.push(Arc::clone(&sub));
                             }
                         }
                         _ => ret_subs.push(Arc::clone(&sub)),
@@ -447,9 +456,9 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                 } else if ret_subs.len() == 1 {
                     let policy = ret_subs.pop().unwrap();
                     (*policy).clone() // More than one strong reference, can't use `try_unwrap()`.
-                } else if is_and {
+                } else if parent_is_and {
                     Policy::Threshold(ret_subs.len(), ret_subs)
-                } else if is_or {
+                } else if parent_is_or {
                     Policy::Threshold(1, ret_subs)
                 } else {
                     Policy::Threshold(m, ret_subs)