Recursive higher-order function
Naming


In Clojure, there's a similar function named juxt.  Not saying that's a better name by any means, just mentioning what it happens to be called in one other place.  Upon further reflection, what you are doing is really just a recursive form of function application.  So a suitable name might reflect that.  Perhaps apply_rec?
Use the shortest name that conveys sufficient meaning.  For example, list_of_functions could be shortened to functions (or even just fs).  possible_function could be shortened to f.  (Single-character names are not good names in general, but for generic entities that have a well-known mathematical notation, they are a good fit.)


Use Better Checks for Callable / Iterable

You check if something's callable by trying to call it and catching a TypeError exception.  However, if you call a function, and that function happens to through a TypeError, then your code will incorrectly assume it's not a function.  You can use the callable function instead, to determine whether or not something is callable.

A similar situation exists in the way you check for iterables.  In this case, you can use the iter function as a fail-fast way to check if something's iterable.

Consider Using a List Comprehension

Reading your code, I thought it was a bit ironic that you used a list comprehension in the docstring to describe the functions behavior, but not in the code itself.  Granted, due to the recursive nature, it's not quite as straight-forward.  But with just a little refactoring, it should be possible.  Here's how I would do it:

def apply_rec(f, x):
  """
  If f is a function, applies f to x and returns the result.
  Otherwise, if f is iterable, applies every element in f to x,
  returning a list of the results.
  If f is neither callable nor iterable, returns f.
  """

  if callable(f):
    return f(x)
  else:
    try:
      fs = iter(f)
    except:
      # Not iterable =&gt; return f
      return f

    return [apply_rec(f, x) for f in fs]


I've omitted the recursion limit, but that should be trivial to add.