The fastest path to finish reading a book as readers in medium English level

There are six kinds of problems to be handled when reading a book,
I illustrate the details as follow:

while True:
    if encounter A :
        handle A
    #during handling the problem, it might spawn new problems of
    #A, B, C, D, E,
        produce  (A,B..E or null)
        continue

    if B occurs:
        handle B
    #during hanlding the problem, it might spwan new problems
    #A, B, C, D, E,
        produce  (A,B..E or null)
        continue

    if C happens:
        handle C
        produce (A,B..E or null)
        continue
    ...

    if there are no problmes:
        break

Suppose I have 3 problems,
the above program might endless loop on first one and never touch the second.

Take an example that I am reading a book,
'Problem A' is defined as encounter a 'new word', handle it is to look up dictionary.
When looking up, I might come acorss another new word, another and another.
In this case, I will never end up reading one sentence of a book.

As a solution,
I introduce a container to collect problems, value-weighted them then determine to execute which one.

def solve_problems(problems)
    problem_backet = list(problems)
    while True:
        if problem_backet not is null:
            #value-weighted all the problem 
            #and determind one to implement
            value_weight problems
            problem = x

        if problem == A:
            handle A
            problem_backet.append(new_problem)
            continue

        if problem == B:
            handle B
            problem_backet.append(new_problem)
            continue
        ...
        if problem_backet is null:
            return 

I tried alternatively to seek inspiration and improve efficiency.

def solve_problems(problems):
    global problem_backet
    problem_backet = list(problems)
    value_weight problems
    problem = x
    if problem == A:
        handle A
        problem_backet.append(new_problem)
        solve_problems(problem_backet)
    if problem == B:
        handle B
        problem_backet.append(new_problem)
        solve_problems(problem_backet)
    if problem == C:
        handle C
        problem_backet.append(new_problem)
        solve_problems(problem_backet)
    ...
    if problem_backet is null:
        return

Again, the value_weighted process consume huge efforts and time.

How to solve such a problem in a proper algorithms?