Fastest Way to Beat Kirby-Paris hydra

Kirby-Paris hydra sequence is the number of steps that beat kirby-Paris hydra totally. But this way used to cut hydra's head is not an optimal way. The strategy used is always to cut right-most inner brackets as you can see in the right image.

I did a study on the fastest way to beat Kirby-Paris hydra. The best strategy should be:

Always cut most inner brackets / deepest level nodes
Among all brackets from above rule, cut the one that has most "brothers".

I name the sequence as optimal_hydra(n). For example, to beat hydra_3 with above stargety:

(((())))
((()()))
((())(())(()))
(()()()()(())(()))
(()()()()()()()()()(()))
(()()()()()()()()()()()()()()())
(()()()()()()()()()()()()()())
(()()()()()()()()()()()()())
(()()()()()()()()()()()())
(()()()()()()()()()()())
(()()()()()()()()()())
(()()()()()()()()())
(()()()()()()()())
(()()()()()()())
(()()()()()())
(()()()()())
(()()()())
(()()())
(()())
(())
()

So optimal_hydra(3)=30

I developed a python program to compute optimal_hydra(n). Consider this format during the game:

all inner brackets are at same level and they are "brothers" to each other like. Assume now is on step s, the most inner brackets are in level i, and there are totally m brothers:

step s: $\underbrace{(...(}_{i}\ \overbrace{()()...()}^{m}\ ) ...)$

After one step, it will change to:

step s+1: $\underbrace{(...(}_{i-1}\ \underbrace{(\ \overbrace{()()...()}^{m-1}\ )...(\ \overbrace{()()...()}^{m-1}\ }_{s+2} ) \ )...)$

After a few more steps, it will eventually change to:

step s+x: $\underbrace{(...(}_{i-1}\ \overbrace{()()...()}^{y}\ ) ...)$

Here, x and y can be computed based on value of original s, i and m. The final python program is:

def brackets_count(m, n, s):
    n = m - 1
    m = s + 2
    s += 1
    while n > 0:
        new_brackets_count = m * (2 * s + m + 1) // 2
        s += m
        m += new_brackets_count
        n -= 1
    return (m, s)

def optimal_hydra(i):
    s = 0
    m = 1
    n = 1
    while i - 1 > 0:
        (m, s) = brackets_count(m, n, s)
        i -= 1
    return s + m

i = 4
print(optimal_hydra(i))

The interesting thing is that this program can compute the exact value of optimal_hydra(4). It has 13598 digits:

optimal_hydra(4)=2655865986803...98221 ${\textstyle \approx 2.656^{13597}}$

I would be happy to see if someone can analysis the growth rate of optimal_hydra(n).