Tiling a staircase with staircases Background
A staircase polyomino is a polyomino made of unit squares whose shape resembles a staircase. More formally, a staircase polyomino of size \$n\$ is defined as follows:

A staircase polyomino of size 1 is a single unit square.
A staircase polyomino of size \$n\$ is the same as that of size \$n-1\$ with a horizontal bar of length \$n\$ attached to the bottom, left-aligned.

Let's call them just staircases for brevity.
For example, here are the staircases of size 1 to 4:
#

#
##

#
##
###

#
##
###
####

Challenge
Given a positive integer \$n\$, calculate the number of ways the staircase of size \$n\$ can be tiled with one or more staircases.
Multiple staircases of same size can be used in a tiling, and the staircases can be rotated. So the following are valid tilings for \$n=4\$:
A
BC
DEF
GHIJ

A
AA
AAA
AAAA

A
AA
BBC
BDCC

Standard code-golf rules apply. The shortest code in bytes wins.
Test cases
Generated using this Python 3 reference solution.
1 -&gt; 1
2 -&gt; 2
3 -&gt; 8
4 -&gt; 57
5 -&gt; 806
6 -&gt; 20840
7 -&gt; 1038266
JavaScript (ES10),  250 ... 228  227 bytes
n=&gt;(e=g=(a,[x]=a)=&gt;+e?e=0:(x&amp;=-x)?a.map((_,s)=&gt;[b=1&lt;&lt;s,...s?[1,b+=~-b,b]:[]].map((m,d)=&gt;d|x&gt;&gt;s&amp;&amp;g(a.flatMap(S=(v,y)=&gt;(S|=y&gt;s?v:(e|=(v^=M=x*m&gt;&gt;!d*s)&amp;M,m^=1&lt;&lt;[s+~y,y+1,s-y,y][d],v))?v:[])))):n++)([...Array(n)].map(_=&gt;2**n---1))|n

Try it online!
How?
The size-\$n\$ staircase is described with an array \$a[\:]\$ of \$n\$ bit masks, going from the longest to the shortest row.
For \$n=4\$, this gives:
# # # #  0b1111 = 15
. # # #  0b0111 = 7
. . # #  0b0011 = 3
. . . #  0b0001 = 1  --&gt; a = [ 15, 7, 3, 1 ]

At each iteration, we remove all the leading empty rows in \$a[\:]\$ and look for the least significant non-zero bit \$x\$ in the first non-empty row. Note that \$x\$ is not set to the index of this bit, but to the corresponding power of \$2\$.
For each \$s\in[0\:..\:n-1]\$ we try to cover the main staircase with another staircase of size \$s+1\$ anchored to the non-zero bit, and whose rows are described with the bit mask \$m\$. If \$s=0\$, we only try the orientation \$d=0\$. Otherwise, we try \$d=0\$ to \$d=3\$.
The table below describes for each value of \$d\$:

the initial value of \$m\$
the index of the bit that must be inverted in \$m\$ to generate the next row
the shift applied to \$m\$

The non-zero bit to which the staircase is anchored is marked with an A. In all cases, \$m\$ is first multiplied by \$x\$ before being shifted. All examples are given with \$x=16\$ and \$s=2\$.
             x           d = 0
       . . . . . . . .
y = 0        A           init.  : 2 ** s
y = 1        # #         bit    : s + ~y  (i.e. s - y - 1)
y = 2        # # #       shift  : &gt;&gt; s
       
             x           d = 1
       . . . . . . . .
y = 0        A           init.  : 1
y = 1      # #           bit    : y + 1
y = 2    # # #           shift  : none
       
             x           d = 2
       . . . . . . . .
y = 0    # # A           init.  : 2 * (2 ** s) - 1
y = 1      # #           bit    : s - y
y = 2        #           shift  : none
       
             x           d = 3
       . . . . . . . .
y = 0    # # A           init.  : 2 * (2 ** s) - 1
y = 1    # #             bit    : y
y = 2    #               shift  : none

Note: Given that the bits to the right of the non-zero bit are all cleared by definition and given that we go from top to bottom, the anchor point of the covering staircase is unambiguously defined for each orientation.