Is a Tree reflexive?

is_reflexive.rs

type OptionBranch = Option<Box<Tree>>;

#[derive(Debug)]
struct Tree {
    data: i32,
    branches: (OptionBranch, OptionBranch)
}

impl Tree {
    fn new(data: i32) -> Self {
        Tree {
            data,
            branches: (None, None)
        }
    }
    
    fn add_branch_left(&mut self, data: i32) {
        match &mut self.branches {
            (Some(_), None) =>  self.branches.1 = Some(Box::new(Tree::new(data))),
            (None, Some(_)) => self.branches.0 = Some(Box::new(Tree::new(data))),
            (Some(x), Some(_)) => x.add_branch_left(data),
            (None, None) => self.branches.0 = Some(Box::new(Tree::new(data)))
        }
    }
    
    fn add_branch_right(&mut self, data: i32) {
        match &mut self.branches {
            (Some(_), None) =>  self.branches.1 = Some(Box::new(Tree::new(data))),
            (None, Some(_)) => self.branches.0 = Some(Box::new(Tree::new(data))),
            (Some(_), Some(y)) => y.add_branch_right(data),
            (None, None) => self.branches.0 = Some(Box::new(Tree::new(data)))
        }
    }
}

fn is_reflexive(root: Tree) -> bool {
    match root.branches {
        (None, None) => true,
        (Some(_), None) => false,
        (None, Some(_)) => false,
        (Some(left), Some(right)) => traverse((left, right))
    }
}

type Branch = Box<Tree>;

fn traverse((left_branch, right_branch): (Branch, Branch)) -> bool {
    match (left_branch.branches, right_branch.branches) {
        ((None, None), (None, None)) => left_branch.data == right_branch.data,
        ((Some(x), None), (None, Some(y))) => traverse((x,y)),
        ((None, Some(x)), (Some(y), None)) => traverse((x,y)),
        ((Some(l_x), Some(l_y)), (Some(r_x), Some(r_y))) => traverse((l_x, r_y)) && traverse((l_y, r_x)),
        _ => false
    }
}

fn main() {
    let mut root = Tree::new(1);
    root.add_branch_left(2);
    root.add_branch_right(2);
    root.add_branch_left(3);
    root.add_branch_left(4);
    root.add_branch_right(4);
    root.add_branch_right(3);
    dbg!(is_reflexive(root));
}

                          1
                2                   2
         3          4        4         3

✅

                          1
                2                   2
         3          4        3         4

❌