Opcodes are a very limited resource, so we need to justify it carefully when adding new ones.

Is pattern matching widely used enough yet to justify this? I don't know.
Is the performance increase enough to justify adding a new instruction?

An approach to optimizing pattern matching that I would be more enthusiastic about is optimizing the decision tree.
This will still need new instructions, but they would be smaller and more easily optimized.

For example, case A(a, b) does both an instance check, and unpacks into a and b, so

match m:
    case A(a, b):
        X
    case A():
       Y

can be transformed into the decision tree, like this:

if m isa A:
    if tmp := unpack_attributes(m, 2):
        a, b = tmp
        X
    else:
        Y

which can be converted into code that has simpler operations and is more amenable to further specialization/jitting.

Inspired by Mark's comments I looked at the generated bytecode:

def g(m):
    match m:
        case A():
            return 100
    return None
import dis
print(dis.dis(g))

Output:

  2           RESUME                   0

  3           LOAD_FAST                0 (m)

  4           LOAD_GLOBAL              0 (A)
              LOAD_CONST               1 (())
              MATCH_CLASS              0
              COPY                     1
              POP_JUMP_IF_NONE         3 (to L1)
              UNPACK_SEQUENCE          0

  5           RETURN_CONST             2 (100)

  4   L1:     POP_TOP

  6           RETURN_CONST             0 (None)
None

This can be simplified to (diff main...eendebakpt:pattern_match_class_v0)

  8           RESUME                   0

  9           LOAD_FAST_BORROW         0 (m)

 10           LOAD_GLOBAL              0 (A)
              LOAD_CONST               0 (())
              MATCH_CLASS              0
              POP_JUMP_IF_FALSE        3 (to L1)
              NOT_TAKEN

 11           LOAD_SMALL_INT         100
              RETURN_VALUE

 12   L1:     LOAD_CONST               1 (None)
              RETURN_VALUE
None

A quick benchmarks shows this is a bit faster.

I tried changing the bytecode generation to use an isinstance check instead of MATCH_CLASS, but that turns out to be slower (even when adding isinstance to the LOAD_COMMON_CONSTANT). Maybe this can be made faster (also for the multi argument case), but that would require some more work.