Finding a path from one wikipedia page to another using semantic similarity of links (Spacy)
First a few observations, then we'll try to improve things.

&quot;Frog&quot; in the first list comprehension should be closest_match (which is initialized to 'frog').
The two list comprehensions are identical, which suggests the code could be rearranged to eliminate the redundancy.
In the while loop, item.similarity() already returns a float, so the float() call is redundant. Also, it seems fishy that the test involves whatever happend to be the last item in link_list_1 or linked_list.
Avoid hard coding &quot;magic numbers&quot; like 1.0, 0.0, and 20 in the code. Use a defined constants with meaningful names to make the code clearer. For example, while item.similarity(nlp(word_2))) != PERFECT_MATCH.
I suspect calling nlp() is computationally expensive, but the code calls nlp(word_2) repeatedly.
word is a poor variable name, particularly when the page titles or links often have multiple words.
If a DisambiguationError is raised, the error is ignored. But, closest_match isn't changed, so the error will repeat the next time through the loop...until the loop count limit is reached.

Now let's try to improve the code.
It looks like the basic idea behind your code is to try to get from one Wikipedia page to a target page by following links. The strategy for picking which link to follow is to pick the one with text that is most similar to the target page name.  There doesn't appear to be any kind of breadth first search or back tracking or anything.
You got the code to grab the links on a page. Right now, the code runs nlp() on each link and check if it is similar to the target before checking if it's already been visited.
raw_links = wikipedia.page(current_page, auto_suggest=False).links
new_links = (link for link in raw_links if link not in path)

According to the spacy documentation it is more efficient to use nlp.pipe(), to process a sequence of texts. nlp.pipe() is a generator that yields a spacy.Doc for each text in the input.
next_pages = nlp.pipe(new_links)

But we want the page with the highest similarity to the target page. The Python builtin max() should work with an approriate key function:
target_page = nlp(target)  # this is done once outside the loop

next_page = max(nlp.pipe(new_links), key=target_page.similarity)

Of course, package it all up in a function:
def find_path(start, target, limit=20):
    start = start.lower()
    target = target.lower()
    
    try:    
        target_page = nlp(target)
    
        current = start
        path = [start]

        for _ in range(limit):
            raw_links = wikipedia.page(current, auto_suggest=False).links
            new_links = (link.lower() for link in raw_links if link not in path)   
            best_page = max(nlp.pipe(new_links), key=target_page.similarity)

            current = best_page.text
            path.append(current)
            
            if current == target:
                return path
                
    except wikipedia.exceptions.DisambiguationError as e:
        print(e)
    
    return []
    
START = &quot;frog&quot;
TARGET = &quot;crystal&quot;    

print(find_path(START, TARGET))

Note: I don't have spacy so I couldn't test this code. It may have some bugs, but based on the docs, I think it should point you in the right direction.