Finding reversed word pairs
As others have mentioned, your program runs slowly because it is doing a lot of membership tests against fairly large lists, which is expensive. If you replace your lists with sets, that alone should improve performance by quite a bit.
Creating a set from the input list of words is also important to ensure the correctness of your algorithm. As @Tweakimp pointed out, we only want to find pairs of opposites within a collection of unique words, to avoid the possibility of duplicates of the same pair from showing up in the results.
Below is a simple algorithm which calculates all the pairs in one pass.

Create unique_words: set[str] from the input list of words.
Create results: list[tuple[str, str]] for our results. This will be our return value.
Create words_seen: set[str] to track which words from unique_words we've seen so far.
Iterate over unique_words; for each word, also calculate reversed_word.

If we haven't seen reversed_word yet, then we don't know if word has a matching pair (yet). So we add word to words_seen.
If we have seen reversed_word, then we just found a matching pair, so we append (word, reversed_word) to results.


Return results.

def find_opposites(words):
    unique_words = set(words)

    results = []
    words_seen = set()

    for word in unique_words:
        reversed_word = word[::-1]

        # if we have already seen reversed_word,
        # then we found a new pair of opposites: (word, reversed_word)
        if reversed_word in words_seen:
            results.append((word, reversed_word))
        else:
            words_seen.add(word)

    return results

Because we start with the set unique_words, we actually don't need to check explicitly for the palindrome case. This is because in order for a palindrome to end up in results, there would need to be at least two instances of the same palindrome in unique_words, which is impossible.