Pólya urn flip and roll
JavaScript (ES7),  145 ... 129 124  123 bytes
Takes input as (r)(n). This is a naive solution that actually performs the entire simulation.

r=&gt;g=(n,B=s=0,R=0,h=d=&gt;++d&lt;7?h(d,[0,d].map(b=&gt;g(n,B/-~!!b,R/-~!b)&amp;g(n,B+b,R+d-b))):s/24**-~n)=&gt;n--?h``:s+=~B&lt;=r*~R|~R&lt;=r*~B

Try it online!
Too slow for the last 2 test cases.
Commented
r =&gt;                    // r = target ratio
g = (                   // g is a recursive function taking:
  n,                    //   n = number of iterations
  B =                   //   B = number of blue beads, minus 1
  s = 0,                //   s = number of times the target ratio was reached
  R = 0,                //   R = number of red beads, minus 1
  h = d =&gt;              //   h = recursive function taking d = 6-sided die value
    ++d &lt; 7 ?           // increment d; if d is less than or equal to 6:
      h(                //   do a recursive call to h:
        d,              //     using the new value of d
        [0, d].map(b =&gt; //     for b = 0 and b = d:
          g(            //       do a first recursive call to g:
            n,          //         leave n unchanged
            B / -~!!b,  //         divide B by 2 if b is not equal to 0
            R / -~!b    //         divide R by 2 if b is equal to 0
          ) &amp; g(        //       do a second recursive call to g:
            n,          //         leave n unchanged
            B + b,      //         add b blue beads
            R + d - b   //         add d - b red beads
          )             //       end of recursive calls to g
        )               //     end of map()
      )                 //   end of recursive call to h
    :                   // else (d &gt; 6):
      s / 24 ** -~n     //   stop recursion and return s / (24 ** (n + 1))
) =&gt;                    // body of g:
  n-- ?                 //   decrement n; if n was not equal to 0:
    h``                 //     invoke h with d = [''] (coerced to 0)
  :                     //   else:
    s +=                //     increment s if:
      ~B &lt;= r * ~R |    //       either (-B-1) &lt;= r*(-R-1), i.e. (B+1)/(R+1) &gt;= r
      ~R &lt;= r * ~B      //       or     (-R-1) &lt;= r*(-B-1), i.e. (R+1)/(B+1) &gt;= r