Perl 6, 36 bytes

{grep {try !.EVAL},[X~] <[ ]>xx$_*2}

Try it online!

Finds all lexographically sorted combinations of $2n$ s and filters the ones that EVAL correctly. Note that all valid combinations (even stuff like ) evaluate to (which is falsey, but we not it (!) to distinguish from try returning Nil)

Explanation:

{                                  }  # Anonymous code block

                        <[ ]>         # Create a list of ("[", "]")

                             xx$_*2   # Duplicate this 2n times

                   [X~]               # Find all possible combinations

 grep {          },                   # Filter from these

            .EVAL                     # The EVAL'd strings

       try !                          # That do not throw an error

Python 2, 91 88 84 81 bytes

f=lambda n:n and sorted({a[:i]+'()'+a[i:]for a in f(n-1)for i in range(n)})or['']

Try it online!

_{-3 bytes thanks to pizzapants184}

05AB1E, 13 bytes

„()©s·ãʒ®õ:õQ

Try it online or verify some more test cases.

Explanation:

„()            # Push string "()"

   ©           # Store it in the register without popping

    s·         # Swap to get the (implicit) input, and double it

      ã        # Cartesian product that many times

       ʒ       # Filter it by:

        ®      #  Push the "()" from the register

         õ:    #  Infinite replacement with an empty string

           õQ  #  And only keep those which are empty after the infinite replacement

Japt, 15 bytes

ç"" á Ôke/

Try it

Explanation

ç""               :Input times repeat the string ""

      á             :Get unique permutations

        Ô           :Reverse

         k          :Remove any that return true (non-empty string)

          e/     :  Recursively replace /[]/g

JavaScript (ES6), 112 102 bytes

This is heavily based on nwellnhof's C answer.

f=(n,i)=>i>>2*n?'':(g=(o,k)=>o[2*n]?s|m<0?'':o:g('()'[m|=s+=k&1||-1,k&1]+o,k/2))(`

`,i,m=s=0)+f(n,-~i)

Try it online!

R, 112 108 bytes

Usual recursive approach.

-1 thanks @Giuseppe

-4 with a change to the Map call.

b=40:41

f=function(n,x=b)`if`(n,sort(unique(unlist(Map(f,n-1,lapply(seq(x),append,x=x,v=b))))),intToUtf8(x))

Try it online!

Ruby, 70 bytes

f=->n{n<1?['']:(0...n).flat_map{|w|f[n-1].map{|x|x.insert w,'()'}}|}

Try it online!

C (gcc), 114 bytes

f(n,x,s,a,i){char b[99]={};n*=2;for(x=1<<n;x--;s|a<0||puts(b))for(s=a=i=0;i<n;)a|=s+=2*(b[n-i]=41-(x>>i++&1))-81;}

Try it online!

Should work for n <= 15.

Explanation

f(n,x,s,a,i){

  char b[99]={};   // Output buffer initialized with zeros.

  n*=2;            // Double n.

  for(x=1<<n;x--;  // Loop from x=2**n-1 to 0, x is a bit field

                   // where 1 represents '(' and 0 represents ')'.

                   // This guarantees lexicographical order.

      s|a<0||puts(b))  // Print buffer if s==0 (as many opening as

                       // closing parens) and a>=0 (number of open

                       // parens never drops below zero).

    for(s=a=i=0;i<n;)  // Loop from i=0 to n-1, note that we're

                       // traversing the bit field right-to-left.

      a|=              // a is the or-sum of all intermediate sums,

                       // it becomes negative whenever an intermediate

                       // sum is negative.

        s+=            // s is the number of closing parens minus the

                       // number of opening parens.

                        x>>i++&1   // Isolate current bit and inc i.

                    41-(        )  // ASCII code of paren, a one bit

                                   // yields 40 '(', a zero bit 41 ')'.

             b[n-i]=               // Store ASCII code in buffer.

          2*(                    )-81;  // 1 for ')' and -1 for '(' since

                                        // we're going right-to-left.

}

Perl 6, 42 bytes

{grep {!S:g/(<~~>*)//},[X~] <( )>xx$_*2}

Try it online!

Uses a recursive regex. Alternative substitution: S/[(<~~>)]*//

38 bytes with 0 and 1 as open/close symbols:

{grep {!S:g/0<~~>*1//},[X~] ^2 xx$_*2}

Try it online!

Explanation

{                                        }  # Anonymous block

                              <( )>         # List "(", ")"

                                   xx$_*2   # repeated 2n times

                         [X~]  # Cartesian product with string concat

                               # yields all strings of length 2n

                               # consisting of ( and )

 grep {                },  # Filter strings

        S:g/             # Globally replace regex match

            (           #   literal (

              <~~>       #   whole regex matched recursively

                  *      #   zero or more times

                   )    #   literal )

                     //  # with empty string

       !                 # Is empty string?

Perl 5 -n, 41 39 bytes

-2 bytes with angle brackets

s/<(?R)*>//gr||say for glob'{<,>}'x2x$_

Try it online!

Port of my Perl 6 answer.

Jelly, 19 bytes

Ø+xŒ!QÄAƑ>ṪƊ$Ƈ=1ịØ(

Try it online!

Output clarified over TIO.

Red, 214 184 bytes

func[n][p:""c: 2 ** d: 2 * n b: copyuntil[a: copy""e: c - 1 loop d[append a p/(e % 2 + 1)

e: e / 2]if not error? try[load a][append/only b a]1 > c: c - 1]foreach a sort b[print a]]

Try it online!

Uses Jo King's approach. Finds all possilble aarangements of brackes by base-2 convertion and then checks if the arrangement evaluates as a valid block.

Retina 0.8.2, 50 bytes

.+

$*

1

11

+%1`1

<$'¶$`>

Gm`^(?<-1>(<)*>)*$(?(1).)

Try it online! Uses <>s. Explanation:

.+

$*

Convert to unary.

1

11

Double the result.

+%1`1

<$'¶$`>

Enumerate all of the 2²ⁿ 2n-bit binary numbers, mapping the digits to <>.

Gm`^(?<-1>(<)*>)*$(?(1).)

Keep only balanced sequences. This uses a balanced parentheses trick discovered by @MartinEnder.