You're along the right lines in identifying that IEnumerable and IEnumerator are very powerful concepts that can often help you in situations like this. However, having to directly deal with an IEnumerator is usually annoying- that's why things like IEnumerable, foreach and yield are there. In this case, consider a wrapper class:

class OneTimeEnumerable<T> : IEnumerable<T>
{
    private IEnumerator<T> _inner;

    public OneTimeEnumerable(IEnumerable<T> source)
    {
        _inner = source.GetEnumerator();
    }

    public IEnumerator<T> GetEnumerator()
    {
        return _inner;
    }
    
    IEnumerator IEnumerable.GetEnumerator()
     {
        return GetEnumerator();
    }
}

All this does is give you an IEnumerable<T> which always returns the same enumerator back (with its Current in the same position), rather than a new one each time. Then you can store this, and foreach over it as usual, rather than having to deal with too-low-level things like MoveNexts.

Note, by the way, that I'm using the generic IEnumerator and IEnumerable. You should pretty much always do this, in the same way that you'd always choose to use a List<Task> to hold tasks rather than a List<object>

Most of the time, a simple foreach iteration over an IEnumerable<T> is what you want for iterative logic. But in some cases- and tree-related algorithms are an area this often occurs- a different data structure will serve you better. In this case, I'd suggest storing your children in a Stack. Then your loop can look like:

    while(subTasks.Any())
    {
        var next = subtasks.Pop();
        Status subtaskStatus = next.Tick( ai );
        switch( subtaskStatus ){
            case Status.SUCCESS: 
                break; //Break switch and move on to next subtask tick..
            case Status.FAILURE:
                return subtaskStatus; //Back out early when any subtask fails.. 
            case Status.RUNNING:
                subtasks.Push(next); //Push it back onto the stack so it'll be first in line next time
                return subtaskStatus; //Back out early and resume/retick running task time!
        }
    }

As a side note, if you do have cause to use IEnumerator and IEnumerable, you should pretty much always use the generic versions, in the same way that you'd always choose to use a List<Task> to hold tasks rather than a List<object>