Optimising an exhaustive search for a card game
I suspect this may be NP-hard in general but probably feasible to solve efficiently in practice for the parameter sizes you discussion.
I will suggest an approach based on comments from j_random_hacker.  One plausible approach is to express this as an integer linear programming problem.  Let $a_{im}$ be the amount of material $j$ you have after the $i$th step of applying sources, $b_{ir} = 1$ if you apply resource $r$ in the $i$th step or 0 otherwise, and then write constraints to express that each step obeys the rules you've followed.  See Express boolean logic operations in zero-one integer linear programming (ILP) for some general techniques for that.  For instance, you'll have a requirement that $a_{im}\ge 0$ for all $i,m$; that $\sum_i b_{ir} \le 1$, that $\sum_r b_{ir} = 1$; and so on.  If you have a resource that contains multiple alternative combinations, treat each as its own resource and then add a constraint that if you pick one of those combinations in any step you can't pick any of the others ($\sum_i \sum_{r \in R} b_{ir} \le 1$, where $R$ is the set of all combinations associated with a single resource).  If resource $r$ is &quot;1 wood -&gt; 1 steel&quot;, then we'd obtain a rule like
$$b_{ir}=1 \implies\\ (a_{i-1,\text{wood}} \ge 1 \land a_{i,\text{wood}} = a_{i-1,\text{wood}} - 1 \land a_{i,\text{steel}} = a_{i-1,\text{steel}}+1).$$
Then, convert that to an ILP constraint using the techniques at the link above.
Finally, you can apply an off-the-shelf ILP solver to search for a solution.
Note that the order in which you applies resources matters, because you can never go negative on any material, which complicates the ILP instance a little bit and requires you to have a separate copy of each variable per step.

If you prefer to adjust your exhaustive search, there may be ways.  One possibility is to use branch-and-bound to prune off some parts of the search space.  At any intermediate point in your search, you can get a simple bound on whether it's possible that a solution could exist from here by picking a single material, say wool, counting how many wool you already have, counting how much more wool you could possibly make if you used every remaining wool-producing resource to produce the maximum amount of wool (assuming optimistically all its preconditions can be met), and checking whether that would give you enough wool to meet the target.  If not, then there's no point continuing the search from here; you can prune the search.  Another way to get a simple bound is to look at the total number of materials, ignoring their type (e.g., total amount of mana, ignoring color); then using each resource that you haven't used so far that increases the number of mana (assuming optimistically that it can be used), and check how much mana total that would give you; if that's not enough for your target, then you can prune the search.
However, ILP solvers already use branch-and-bound, and they are probably doing something that generalizes  this and is more powerful.  So, rather than implementing branch-and-bound yourself with some limited set of bounds, I suspect it might be more powerful to use a full ILP solver.