Jelly, 18 17 15 bytes

ṃUN;;Ʋ}F;Ṗ+Ṫ¥?/

Try it online!

-1 thanks to Jonathan Allan

-2 with even more duplicates

Takes a 1-index on the right, and the words as positive and negative integers on the left, outputting with a substantial number of duplicates corresponding not only to equivalent concatenations of different words but also to concatenations of the exact same words. Not shortest-first--it takes up to index 210 447 to generate the single d on the last test case.

 UN   }            Reverse and negate each word,
   ; Ʋ             concatenate the original words,
    ;Ʋ             and concatenate the original words again.
ṃ                  Base decompress the index into that
       F           then flatten the resulting words together.
              /    Reduce left to right by:
             ?     If
          +Ṫ¥      the new symbol's sum with the last symbol of the accumulator
        ;    ?     is nonzero, then concatenate it to the end,
         Ṗ   ?     else remove the last symbol.

The issue with ṃ--"Base decompression; convert x to base length(y) then index into y."--is that it does exactly what it says on the tin. Since it converts to a standard positional numeral system (as opposed to bijective, as the previous version of this solution used) and directly 1-indexes the resulting digits into the list, the first element of its output can never be the last element of its right argument, because the base conversion can never generate a leading 0. Fortunately, being allowed to generate duplicate outputs offers a very expedient, if messy, fix: duplicate the last element, so it can still appear as the first element of output by virtue of being generated by its earlier occurrence in the list instead.

Haskell + hgl, 79 70 bytes

-9 bytes thanks to Wheat Wizard

f w=nn>~rF(#)[]<<fo<<mM(p$ap[id,rv<m Ng]w)<e0
a#(h:t)| -h==a=t
a#b=a:b

Attempt This Online!

Takes positive and negative numbers as input.

Semi-Ungolfed:

invertWord = reverse . map negate
mkInvertedWords w = w ++ map invertWord w
cartesianPower l n = mapM (\_ -> mkInvertedWords l) [0..n]

reduceWords :: [[Int]] -> [Int]
reduceWords = foldr (#) [] 

-- This function implements the cancellation of inverses
a#(h:t)| -h==a=t
a#b=a:b

f w = do
 n <- [0..]
 return map reduceWords $ cartesianPower w n

Jelly,  24  23 bytes

FµŻSƝaSƝTị
UN;ƊṗⱮẎÇÐL€ḣ

A dyadic Link that accepts the list of words on the left, and a non-negative integer, \$n\$, on the right and yields a list of the first \$n\$ elements.

The words use an alphabet of positive integers and their negation to represent an inverse.

The sequence includes many repeats as well as the empty word (also repeatedly).

Don't Try it online! as it's crazy slow.

For the sequence using up to \$n\$ words try this instead.

How?

FµŻSƝaSƝTị - Link 1, "Simplify Once": list of Words OR Word
F          - flatten the list of Words (no-op when passed Word)
 µ         - start a new monadic Link - f(S=that):
  Ż        -   prefix with a zero
   SƝ      -   sum of each neighbouring pair of that
      SƝ   -   sum of each neighbouring pair of S
     a     -   logical AND these together
                 (vectorises and takes the left when the right expires)
        T  -   truthy indices
         ị -   index into S -> S with offsetting neighbours removed

UN;ƊṗⱮẎÇÐL€ḣ - Main Link: StartingWords, Index
   Ɗ         - last three links as a monad - f(StartingWords):
U            -   reverse each {StartingWords}
 N           -   negate -> InverseWords
  ;          -   concatenate {StartingWords}
     Ɱ       - map across {C in [1..Index]} with:
    ṗ        -   Cartian power -> all wordlists of length C
      Ẏ      - tighten -> list of the wordlists
          €  - for each:
        ÐL   -   apply until no change:
       Ç     -     call Link 1 as a monad
           ḣ - head to {Index}

Charcoal, 54 bytes

⊞υωＷＳ«⊞υι⊞υ⭆⮌ι⎇№ακ↧κ↥κ»≔⍘ＮυθＷΦＥ⪫υω⁺κ⎇№ακ↧κ↥κ№θκ≔⁻θ⌊ιθθ

Try it online! Link is to verbose version of code. Takes a newline-terminated list of newline-terminated words followed by n as input and outputs the nth term (1-indexed excluding the empty term, but if you run this on ATO instead then it will be 0-indexed including the empty term) including many, many duplicates. Explanation:

⊞υω

Start with just an empty string.

ＷＳ«

Loop through the words.

⊞υι

Add the word to the list.

⊞υ⭆⮌ι⎇№ακ↧κ↥κ

Add the inverse of the word to the list.

»≔⍘Ｎυθ

Input n and convert it to base 2m+1, where m is the number of words.

ＷΦＥ⪫υω⁺κ⎇№ακ↧κ↥κ№θκ≔

For each symbol in the words and their inverses, concatenate the symbol with its inverse. While at least one of those pairs exists in the result...

⁻θ⌊ιθ

... remove one of them from the result.

θ

Output the final result.

Bonus 58-byte version that outputs the first n terms: Attempt This Online! Link is to verbose version of code.

Pyth, 25 bytes

#jmu?s>2K+GHKPGsdYy=+m__M

Try it online!

Words are lists of non-zero integers where inversing is done by negation.

Generates output infinitely with many repeated terms, including the empty list.

Explanation

#jmu?s>2K+GHKPGsdYy=+m__MdQQ    # implicitly add dQQ
                                # implicitly assign Q = eval(input())
                   =      Q     # assign to Q
                     m    Q     #   map lambda d over Q
                       _Md      #     negate each element of d
                      _         #     and reverse
                    +      Q    #   concatenated with Q
  m               y             # map powerset of Q over lambda d
   u           sdY              #   reduce sum(d) over lambda G,H with [] as starting value
        K+GH                    #     assign K to the concatenation of G and H
    ?                           #     ternary operator, return the following
     s>2K                       #     if sum(K[-2:]) != 0:
            K                   #       K
                                #     else:
             PG                 #       G[:-1]
 j                              # print, sperated by newlines
#                               # repeat infinitely