Who can escape the Nonary Game?
JavaScript (ES6), 219 bytes
A slower but significantly shorter version using bitmasks instead of strings.

f=(D,P=[511],e=m=0)=&gt;P.map((X,r)=&gt;[...Array(-~X)].map((_,p)=&gt;D.map(([d,s,t],j)=&gt;(N=(g=(n,k)=&gt;n&amp;&amp;n%2+g(n&gt;&gt;1,++k,x+=n%2*k))(p&amp;=X,x=0))&lt;3|N&gt;5|r-s|x%9^d%9||f(D.filter(_=&gt;j--),A=[...P],e+!~t*N,A[r]^=p,A[t]^=p))),m=m&gt;e?m:e)|m

Try it online!
NB: The reason why it's slower is that we do not compute the powersets of the players. Given a bitmask of players \$X\$, we iterate on all \$(X \operatorname{AND} p)\$ for \$0\le p\le X\$ without deduplicating.

JavaScript (ES7),  293 272  271 bytes
Takes input in the format described in the challenge. This is a brute force search.

f=(D,P=[17**6+'8'],e=m=0)=&gt;P.map((X,r)=&gt;X&amp;&amp;[...X].reduce((a,x)=&gt;[...a,...a.map(y=&gt;y+x)],['']).map(p=&gt;D.map(([d,s,t],j)=&gt;p&lt;99|p[5]|r-s|eval([...p].join`+`)%9^d%9||f(D.filter(_=&gt;j--),A=[...P],e+!~t*p.length,A[r]=X.replace(eval(`/[${p}]/g`),''),A[t]=[A[t]]+p))),m=m&gt;e?m:e)|m

Try it online! (the first test case times out on TIO)
How?
The array P[] holds a list of strings describing the players in each room.
We start with P=['241375698'] (using \$17^6=24137569\$), which means that all players are initially located in room \$0\$.
For each room X at position r, we compute the powerset of X:
[...X].reduce((a, x) =&gt; [...a, ...a.map(y =&gt; y + x)], [''])

For each group of players p in there and for each door [d,s,t] at index j, we test if the group is unable to pass through the door:
                         // we can't pass if:
p &lt; 99 |                 // there are less than 3 players
p[5] |                   // or there are more than 5 players
r - s |                  // or the source room s is not equal to the current room
eval([...p].join`+`) % 9 // or the sum of the players modulo 9
^ d % 9                  // does not match the ID of the door modulo 9

If the group can pass, we do a recursive call:
f(                       //
  D.filter(_ =&gt; j--),    // remove the door that has just been used from D[]
  A = [...P],            // use a copy A[] of P[]
  e + !~t * p.length,    // if t = -1, add the length of p to e (number of escaped guys)
  A[r] = X.replace(      // remove the players from the source room A[r]
    eval(`/[${p}]/g`),   //
    ''                   //
  ),                     //
  A[t] = [A[t]] + p      // and append them to the target room A[t]
)                        //

We keep track of the maximum number of escaped players in m and eventually return it.