You're experiencing the typical and, in the simple example, expected limitations of searching for roots. The two FindRoot results are easily understood in terms of Newton's method. The best way to proceed, assuming given the example is typical, is to use WhenEvent.
sol = NDSolve[{y''[t] == -y[t], y[0] == 1, y'[0] == 0,
WhenEvent[y[t] == 0, firstzero = t; "RemoveEvent"]}, y, {t, 0, 10}];
firstzero
(* 1.5708 *)
If firstzero is not accurate enough, use it as a starting point for FindRoot.
FindRoot[y[t] == 0 /. sol, {t, firstzero, 0, 10}]
(* {t -> 1.5708} *)
Addendum -- What's happening in Newton's method
Basically the first step in both of the OP's examples goes outside the domain of the solution. Stepping outside the domain of an interpolating function usually leads to unpredictable results.
FindRoot[y[t] == 0 /. sol, {t, 0, 0, 10}]
FindRoot::reged: The point {0.} is at the edge of the search region {0.,10.} in coordinate 1 and the computed search direction points outside the region. >>
(*
{t -> 0.}
*)
Note the derivative is slightly positive at the initial point t == 0, indicating that the next step should be in the negative direction.
y'[0] /. sol
(*
{2.71051*10^-20}
*)
In the second case, the starting is just not close enough to the root.
FindRoot[y[t] == 0 /. sol, {t, 0.1, 0, 10}]
FindRoot::reged: The point {10.} is at the edge of the search region {0.,10.} in coordinate 1 and the computed search direction points outside the region. >>
(*
{t -> 10.}
*)
The derivative is so small that the first step goes just beyond the domain again:
y'[0.1] /. sol
0.1 - y[0.1]/y'[0.1] /. sol
(*
{-0.0998334}
{10.0666}
*)
If you do not have any information about the roots, then a direct search, which is what WhenEvent is essentially doing above, seems necessary. In terms of built-in functions, NDSolve seems hard to beat when you are already using it to construct the function. One could use Plot, but it seems more likely to miss two close zero-crossings. Even if a function f[t] is obtained by other means, if it is differentiable, this should be efficient and robust:
NDSolve[{y'[t] == f'[t], y[0] == f[0],
WhenEvent[y[t] == 0, firstzero = t; "StopIntegration"]}, y, {t, 0, 10}];
If the derivative f'[t] cannot be calculated, then Plot is probably the best bet. Then one could use Brent's method.
Related: How to find numerically all roots of a function in a given range?
Update 2021.5.25
At some point in the past, I believe the following did not work, but a few versions ago (I think), NSolve was updated to call InverseFunction when the interpolating function can be isolated. Perhaps InverseFunction was updated to handle InterpolatingFunction, too. NSolve and InverseFunction seem to return the first root only.
NSolve[y[x] == 0 /. sol, x]
NSolve::ifun: Inverse functions are being used by NSolve, so some solutions may not be found; use Reduce for complete solution information.
(* {{x -> 1.5708}} *)
InverseFunction[y /. First@sol][0.`]
(* 1.5708 *)
FindRoot[y[t] == 0 /. sol, {t, 0.5, 0.7}]) leads to the $\pi/2$ solution. On the other hand, if you start with $0$ but restrict the search domain to that over which you solved the differential equation (e.g.FindRoot[y[t] == 0 /. sol, {t, 0, 0, 10}]) you get an error explaining the weird behavior you observed ("The point {0.} is at the edge of the search region {0.,10.} in coordinate 1 and the computed search direction points outside the region."). $\endgroup$