TODO for MBTF (in approximate order of priority):
    1.  Redo path following to allow for better memory usage and removal of
        duplicate path generation.
       
            a.  For state iterator nodes, we don't need to keep previously
                visited inner-transition objects, as they will be regenerated
                when the iterator flips back.
            
            b.  If we examine when a duplicate path can occur, we notice that
                at depth X, if every path has a depth of X, then they are all
                guaranteed to be unique (I should hard prove this, or find a
                proof for it).  However, if at depth X+1, some paths have a
                depth of X+1, and some have a depth of X (due to terminating
                nodes).  Those paths at depth X are duplicates of depth X
                paths, due to the fact that depth X generated *all possible
                paths* for paths with depth X.
                
                Solution: we can optimize our search by expanding the return
                value of path addition: 0 = did not flip over to another path,
                1 = did flip over to another path, and 2 = reached terminating
                node.  Parent nodes will behave identically as before, except
                that:
                    i.  immediately after getting the return value, check if it
                        is 2.  If so, then remove that transition from the
                        list of transitions searchable - all later
                        investigations of that path will cause duplicates to
                        occur.
                    ii. check for our action.  if the value is non-zero, act
                        as if the child node flipped itself, and advance the
                        parent's next transition to the next one.  If there
                        are 0 next transitions remaining, then return 2.
                        If this node flipped over in its advance of the next
                        node, then return 1.