Calculate the n-th iterate of a polynomial for a specific value; fⁿ(x) Given a polynomial function f (e.g. as a list p of real coefficients in ascending or descending order), a non-negative integer n, and a real value x, return:
   f n(x)
i.e. the value of f (f (f (…f (x)…))) for n applications of f on x.
Use reasonable precision and rounding.
Solutions that take f as a list of coefficients will probably be the most interesting, but if you are able to take f as an actual function (thereby reducing this challenge to the trivial &quot;apply a function n times&quot;), feel free to include it after your non-trivial solution.
Example cases
p =[1,0,0] or f =x^2, n =0, x =3: f 0(3) =3
p =[1,0,0] or f =x^2, n =1, x =3: f 1(3) =9
p =[0.1,-2.3,-4] or f =0.1x^2-2.3x-4, n =0, x =2.3: f 0(2.3) =2.3
p =[0.1,-2.3,-4] or f =0.1x^2-2.3x-4, n =1, x =2.3: f 1(2.3) =-8.761
p =[0.1,-2.3,-4] or f =0.1x^2-2.3x-4, n =2, x =2.3: f 2(2.3) =23.8258
p =[0.1,-2.3,-4] or f =0.1x^2-2.3x-4, n =3, x =2.3: f 3(2.3) =-2.03244
p =[0.1,-2.3,-4] or f =0.1x^2-2.3x-4, n =4, x =2.3: f 4(2.3) =1.08768
p =[0.1,-2.3,-4] or f =0.1x^2-2.3x-4, n =5, x =2.3: f 5(2.3) =-6.38336
p =[0.1,-2.3,-4] or f =0.1x^2-2.3x-4, n =6, x =2.3: f 6(2.3) =14.7565
p =[0.1,-2.3,-4] or f =0.1x^2-2.3x-4, n =7, x =2.3: f 7(2.3) =-16.1645
p =[0.1,-2.3,-4] or f =0.1x^2-2.3x-4, n =8, x =2.3: f 8(2.3) =59.3077
p =[0.1,-2.3,-4] or f =0.1x^2-2.3x-4, n =9, x =2.3: f 9(2.3) =211.333
p =[0.1,-2.3,-4] or f =0.1x^2-2.3x-4, n =10, x =2.3: f 10(2.3) =3976.08
p =[0.1,-2.3,-4] or f =0.1x^2-2.3x-4, n =11, x =2.3: f 11(2.3) =1571775
p =[-0.1,2.3,4] or f =−0.1x^2+2.3x+4, n =0, x =-1.1: f 0(-1.1) =-1.1
p =[-0.1,2.3,4] or f =−0.1x^2+2.3x+4, n =1, x =-1.1: f 1(-1.1) =1.349
p =[-0.1,2.3,4] or f =−0.1x^2+2.3x+4, n =2, x =-1.1: f 2(-1.1) =6.92072
p =[-0.1,2.3,4] or f =−0.1x^2+2.3x+4, n =14, x =-1.1: f 14(-1.1) =15.6131
p =[0.02,0,0,0,-0.05] or f =0.02x^4-0.05, n =25, x =0.1: f 25(0.1) =-0.0499999
p =[0.02,0,-0.01,0,-0.05] or f =0.02x^4-0.01x^2-0.05, n =100, x =0.1: f 100(0.1) =-0.0500249
Octave, 49 bytes

@(p,x,n)(f=@(r,m){@()p(r(r,m-1)),x}{~m+1}())(f,n)

Try it online!
Or, taking coefficients:
Octave, 75 57 bytes

@(p,x,n)(f=@(f,n){@()polyval(p,f(f,n-1)),x}{~n+1}())(f,n)

Try it online!
A special thanks for Suever over at StackOverflow, for this answer some time ago on a question of mine, proving that a recursive anonymous function is possible.
This defines an anonymous function, which is a wrapper for a recursive anonymous function; something which is not a native Octave concept, and requires some fancy cell array indexing.
As a bonus, the second version is a nice lesson in variable scoping in Octave. All instances of r can legally be replaced by f, which then simply overwrites the existing f in the most local scope (similar for n)
Explanation
@(p,x,n)(f=@(r,m){@()p(r(r,m-1)),x}{~m+1}())(f,n)
@(p,x,n)         .                ..    .  ..   .   % Defines main anonymous function    
        (f=@(r,m).                ..    .  ).   .   % Defines recursive anonymous function
                 .                ..    .   .   .   %  r: Handle ('pointer') to recursive function
                 .                ..    .   .   .   %  m: Current recursion depth (counting from n to 0)
                 .                ..    .   (f,n)   % And call it, with
                 .                ..    .           %  r=f (handle to itself)
                 .                ..    .           %  m=n (initial recursion)
                 {                }{    }           % Create and index into cell array
                                    ~m+1            %  Index: for m&gt;0: 1; for m==0: 2.
                                ,x                  %  Index 2: final recursion, just return x.
                  @()                               %  Index 1: define anonymous function, taking no inputs.
                     p(        )                    %   which evaluates the polynomial 
                       r(     )                     %    of the recursive function call
                         r,m-1                      %     which is called with r 
                                                    %     and recursion depth m-1 
                                                    %     (until m=0, see above)
                                         ()         % Evaluate the result of the cell array indexing operation.
                                                    %  which is either the anonymous function
                                                    %  or the constant `x`.

The key to this is that anonymous functions are not evaluated when they are defined. So, the @(), which seems a bit superfluous since it defines an anonymous function which is called with () directly after, is actually strictly necessary. It is not called unless it is selected by the indexing statement.
Octave, 39 bytes (boring way)

function x=f(p,x,n)for i=1:n;o=p(o);end

Just for completeness, the Octave solution with the shortest bytecount.
Yawn..