Rust solution:

fn completer(bracket: char) -> char {
    match bracket {
        '[' => ']',
        '{' => '}',
        '(' => ')',
        ')' => '(',
        '}' => '{',
        ']' => '[',
        _ => unreachable!(),
    }
}

fn rec(v: &mut Vec, stack: &mut Vec, depth: usize) {
    // If we have more characters in the stack to complete
    // than the space avaiable, bail!
    if stack.len() > depth {
        return;
    }

    if depth == 0 {
        let output: String = v.iter().collect();
        println!("{}", output);
        return;
    }

    for b in &['[', '{', '('] {
        v.push(*b);
        stack.push(*b);
        rec(v, stack, depth - 1);
        stack.pop();
        v.pop();
    }

    if let Some(c) = stack.pop() {
        v.push(completer(c));
        rec(v, stack, depth - 1);
        stack.push(c);
        v.pop();
    }
}

fn main() {
    let depth: usize = std::env::args().nth(1).unwrap().parse().unwrap();
    let mut v = Vec::with_capacity(depth);
    let mut s = Vec::with_capacity(depth / 2);
    rec(&mut v, &mut s, depth);
}

Hope you enjoy this!

Edit: Lemmy makes the usize in angle brackets disappear after parse::. Idk what to do.

Edit: I kinda fixed it by assigning the type as a part of the variable definition.

Note to self: the angle bracket problem persists nonetheless.

Factor:

USING: kernel regexp command-line namespaces sequences io math.combinatorics math.parser ;
IN: l

: g ( s -- ? )
  R/ (\{\}|\(\)|\[\])/
  [
    over empty? [ f ] [
      2dup re-contains?
      pick [ first "[{(" member? ] [ last "]})" member? ] bi
      and and
    ] if
  ] [
    [ "" re-replace ] keep
  ] while drop empty?
;

: a ( n -- )
  "(){}[]" swap [
    dup g [ print ] [ drop ] if
  ] each-selection
;

MAIN: [ command-line get [ string>number a ] each ]

Rust:

A super simple brute force attempt: https://pastebin.com/qbYQNQ7h

Also super slow. Took me a bit more than a minute for n=10.

edit: An updated version: https://pastebin.com/wVhxLmt9

Added some simple constraints to reduce the number of unfiltered entries that need to be generated, bringing the n=10 time down to 10ish seconds. EDIT: if any of the test cases are n=12 or greater, probably best to fail this without testing. It’s super inefficient memory wise.

Older solution that doesn’t work quite right

const BRACKETS = [['(', ')'], ['[', ']'], ['{', '}']];

function brackets(n) {
  if (n === 1) return ['()', '[]', '{}'];
  let o = {};

  function addBracket(s) {
    BRACKETS.forEach(b => {
      o[b[0] + b[1] + s] = true;
      o[b[0] + s + b[1]] = true;
      o[s + b[0] + b[1]] = true;
    });
  }

  brackets(n - 1).forEach(addBracket);
  return Object.keys(o);
}

brackets(Number(process.argv[2]) / 2).forEach(v => console.log(v));

I revised it because I was pointed out I missed an aspect of the problem. This is in JavaScript

const BRACKETS = ['()', '[]', '{}'];

function brackets(n) {
  if (n === 0) return [''];

  let strings = brackets(n - 1);

  let o = {};
  for (let s of strings) {
    for (let i = 0; brackets.length >= i; i++) {
      for (let b of BRACKETS) {
        o[s.slice(0, i) + b + s.slice(i)] = true;
      }
    }
  }

  return Object.keys(o);
}

brackets(Number(process.argv[2]) / 2).forEach(v => console.log(v));

Factor, take 2: much longer, much faster:

USING: kernel regexp command-line namespaces sequences io math.combinatorics math.parser math strings ;
IN: l

: g ( s -- ? )
  R/ (\{\}|\(\)|\[\])/
  [
    2dup re-contains?
    pick empty? not
    and
  ] [
    [ "" re-replace ] keep
  ] while drop empty?
;

: a ( n -- )
  2 -
  dup neg? [ drop ] [
    dup 0 = [ drop "{}" "[]" "()" [ print ] tri@ ] [
      "{[(" "}])" cartesian-product concat swap
      "(){}[]" swap [
        over
        [
          [ dup ] dip
          [ first ] [ last ] bi [ 1string ] bi@
          surround
          dup g [ print ] [ drop ] if
        ] each drop
      ] each-selection drop
    ] if
  ] if
;

MAIN: [ command-line get [ string>number a ] each ]