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

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

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

[Try it online!](https://tio.run/##XY1BasMwFET3PUU2Df/bPzJyXAjGkukFdIHgEuMoRiVIQkqMAr276ybZNKth3gwz3/3UxyEYf9lYd9TzScxWSBgFaJrIo5B7xthnCP0NlCgzi6Q2nDjZjgV9vA4aIFIiszQnKSEJ06jW1ODzhO8K17yNdcxHACOFwsK3f3uafJNan9nM5qlOd/VdvVz@8KZJlJDGvWbRhQtg9wWL6QRHxMNhHpyN7qzZ2Y1wggWuimJVvv3H5QNvqxe@fdYr/hJUj4B/7Mr5Fw "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
          n                       //   - N+2    : opposite vertex
        ].reduce((s, x, i) =>     // reduce() loop with s = accumulator, x = vertex, i = index:
          v >> (x = i < N         //   test the x-th bit of the bitmask v, with:
                    ? i           //     x = i if i < N
                    : (p + x) % N //     or (p + x) mod N otherwise
          ) & 1 ?                 //   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[]:
                  p < x           //           the edge formed by p and x
                  ? p * n * n + x //           and uniquely identified by
                  : x * n * n + p //           min(p, x) * n² + max(p, 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 = ['']