Is there a name for this graph search strategy? The standard implementation of breadth-first search looks like

queue = [root]
while queue:
    node = queue.pop()
    visit(node)
    for_each child in node.children:
        queue.push(child)


Just by switching the queue to a stack:

stack = [root]
while stack:
    node = stack.pop()
    visit(node)
    for_each child in node.children:
        stack.push(child)


we get depth-first search.

There is another way to write breadth-first search:

visit(root)
queue = [root]
while queue:
    node = queue.pop()
    for_each child in node.children:
        visit(child)
        queue.push(child)


But when you switch this one from a queue to a stack:

visit(root)
stack = [root]
while stack:
    node = stack.pop()
    for_each child in node.children:
        visit(child)
        stack.push(child)


You do not get a traditional depth-first search.  Instead, you get a variant where all a node's immediate children are visited first, then its other ancestors in a depth-first way.  For example, on this tree:

     F
   /   \
  B     G
 / \     \
A   D     I
   / \   /
  C   E H


Depth-first search gives the order


  [F, G, I, H, B, D, E, C, A]


The last algorithm gives the order


  [F, B, G, I, H, A, D, C, E]


which is not exactly depth-first because B and G are both visited before I.  Does this algorithm have a name?
I don't think it has any standard name, but you might arguably call it a depth-first search with one level of lookahead.