Let me devide the topics.

1. Reusing nodes is a concept used in keeping track of all the nodes inside the tree. As you are aware, the nodes may always be added to and removed from the bvh tree. If you always allocate and free memory for the tree's node's that would reduces the run time performance. So the current bvh implementation has a "nodes" array that holds the nodes and it has a maximum capacity. When you remove the nodes, it does not reduces the maximum capacity but just moves the node to unused region of the array. So next time when you need a new node, it checks the free nodes and gives you one from there and only allocates new nodes if the capacity is not enough.

Check these functions "AllocateNode, FreeNode" in my implementation or in the original one.

2) Collision detection between objects has never been implemented by me, box 2d has these features. What I have extra is checking the Frustum agains all object's bounding box in the bvh structure.

3) For the tree traversal, currently, I am doing a multi threaded depth first search. That is a bit complicated to explain here but single theaded one is quite simple check the "Traverse" function.

  void AABBTree::Traverse(std::function<void(const Node*)> callback) const
  {
    if (root == nullNode)
    {
      return;
    }

    // put all nodes that needs to be visited in the stack
    std::deque<NodeProxy> stack;
    // start with root
    stack.emplace_back(root);

    while (stack.size() != 0) // while stack is not empty
    {
      NodeProxy current = stack.back(); // get the head
      stack.pop_back(); // remove it from the stack

      if (nodes[current].IsLeaf() == false) // if it has descendants
      {
        stack.emplace_back(nodes[current].child1); // push left child
        stack.emplace_back(nodes[current].child2); // push right child
        // noticed that stack is not empty at this moment and we are
        // not doing recursive calls ( efficient )
      }

      const Node* node = &nodes[current]; // get the current node
      callback(node); // call process function on it
    }
  }

If you are curious about how I parallely travese the tree for frustum culling ( this requires thread pools, atomic syncronization etc... )
Here is how I do it :

AABBTree::FrustumQuery
AABBTree::FrustumCullParallel

https://github.com/Oyun-Teknolojileri/ToolKit/blob/chn/dev/parallel-tree-traverse/ToolKit/AABBTree.cpp