#JavaScript (ES6), <s>&nbsp;160 158&nbsp;</s> 146 bytes

<!-- language-all: lang-javascript -->

    n=>(g=(e,v,p)=>[...Array(N=2*n),N-1,1,n].reduce((s,x,i)=>(m=1<<(x=i<N?i:(p+x)%N))&v?s:s+g((i>=N)/p?[...e,1<<p|m]:e,v|m,x),g[e.sort()]^(g[e]=1)))``

[Try it online!](https://tio.run/##XY1BasMwEEX3PUU2DTPNREaOA8V4bHoBXSC4xDiKUYklISXGhdzdVUk3zfK///j/q5u62Afjr1vrTno582K5hoFB00QeuT4IIT5C6L5Bcf5mkdRWkiTbiqBPt14DRJrJJBNGllUFM5tKNaYEv5nxVSGupyaWcTMAmJoVZr753dSUZH8f2zI93UeakYaDFtGFK2D7CSm0LBHxeFx6Z6O7aHFxA5whwVWWrfKX/zh/4F3xxHd/eiGfiuJRyP17vvwA "JavaScript (Node.js) – Try It Online")

Notes:

- This is quite inefficient and will time-out on TIO for \$n>4\$.
- \$a(5) = 10204\$ was found in a bit less than 3 minutes on my laptop.

###Commented

    n => (                        // n = input
      g = (                       // g = recursive function taking:
        e,                        //   e[] = array holding visited edges
        v,                        //   v   = bitmask holding visited vertices
        p                         //   p   = previous vertex
      ) =>                        // we iterate over an array of N + 3 entries, where N = 2n:
        [ ...Array(N = 2 * n),    //   - 0...N-1: each vertex of the N-gon
          N - 1,                  //   - N      : previous vertex \
          1,                      //   - N+1    : next vertex      }-- connected to p
          n                       //   - N+2    : opposite vertex /
        ].reduce((s, x, i) =>     // reduce() loop with s = accumulator, x = vertex, i = index:
          ( m = 1 << (            //   m is a bitmask where only the x-th bit is set
              x = i < N           //   and x is either:
                  ? i             //   - i if i < N
                  : (p + x) % N   //   - or (p + x) mod N otherwise
          )) & v ?                //   if this vertex was already visited:
            s                     //     leave s unchanged
          :                       //   else:
            s +                   //     add to s
            g(                    //     the result of a recursive call:
              (i >= N) / p ?      //       if p and x are connected (i >= N and p is defined):
                [ ...e,           //         append to e[]:
                  1 << p | m      //           the edge formed by p and x
                ]                 //           and uniquely identified by 1 << p | 1 << x
              :                   //       else:
                e,                //         leave e[] unchanged
              v | 1 << x,         //       mark the vertex x as visited
              x                   //       previous vertex = x
            ),                    //     end of recursive call
          g[e.sort()] ^           //   sort the edges and yield 1 if this list of edges has not
          (g[e] = 1)              //   already been encountered; either way, save it in g
        )                         // end of reduce()
    )``                           // initial call to g with e = ['']