I will assume that the spanning forest is given as indicating the parent of each node (with a special value for the parents of the roots of the forest), or as the list of edges in the spanning forest.
That means that we don't know in which order the nodes have been seen.
Let us denote $G = (V, E)$ the graph and $G_F = (V, F)$ the spanning forest, with $F \subseteq E$.
A recursive idea
First, if the spanning forest is $(T_1, T_2, …, T_k)$, with $T_i$ as trees, if the trees are seen in this order, that means that there is never an edge (of $E\setminus F$) between a vertex of $T_i$ and a vertex of $T_j$ for $i < j$, otherwise the tree $T_i$ would just contain some vertices of $T_j$.
To check that, consider the graph $G_T = (V_T, E_T)$, with $V_T = \{T_1, T_2, …, T_k\}$ and $(T_i, T_j)\in E_T$ if and only if there is some $(u, v)\in E$, with $u\in T_i$ and $v\in T_j$. What we need to verify is that $(T_k, T_{k-1}, …, T_1)$ is a topological ordering. Actually, since we don't know the ordering $(T_1, …, T_k)$, we just need to verify that $G_T$ is acyclic (that would mean that such an ordering is possible). This can be verified in linear time using a postorder DFS.
Second, each tree $T_i$ need to be a possible spanning tree produced by a DFS on the graph $G[T_i]$ (the graph $G$ restricted to vertices of $T_i$ and edges between those).
For that, if the root of a tree $T$ is $r$, and its children are $c_1, …, c_m$, then $T$ is a possible DFS spanning tree of $G[T]$ if and only if $(c_1, …, c_m)$ is a possible DFS spanning forest of $G[T\setminus r]$! This gives the idea of a nice recursive algorithm, the base case being a graph with one vertex.
Correctness
As stated before, the acyclicity of the graph between trees is a necessary condition. But is verifying this condition recursively sufficient?
For that, assume that we get an ordering $(T_1, T_2, …, T_k)$ that is a reverse topological ordering of the graph $G_T$, and assume that $T_i$ is a spanning forest that can be obtained from a DFS in $G[T_i]$ for each $T_i$. If you denote $r_1, …, r_k$ the roots and scan vertices in this order (the other vertices coming after that), and each time you have a choice between several vertices, you make the same choices as the ones that can get you $T_1, …, T_k$ as spanning trees, you will get exactly this spanning forest.
Time complexity
The time complexity has an induction formula like
$$C(V, E) = \sum\limits_{i=1}^k C(V_i, E_i) + \mathcal{O}(|V| + |E|)$$
where $G[T_i] = (V_i, E_i)$. This is due to the fact that constructing $G_T$, verifying its acyclicity and constructing all $G[T_i]$ can be done in linear time.
Now I am no so sure about the analysis of that formula, but my guess would be that it is $\mathcal{O}(|V|^2 + |E|^2)$. There may be a more efficient algorithm.