This could be a matter of when the function is evaluated. If OddQ is evaluated on symbolic as opposed to numeric input it will return False right away. Similar with the If as opposed to a more "mathematical" formulation.

General advice: When possible, use mathematical rather than procedural code inside functions like NDSolve. For example, use Piecewise rather than If. When not possible, force the function to remain "inert" unless given explicit numeric input. This is done by restricting input patterns, with constructs like f[x_?NumberQ]:=.... See NDSolve documentation for further details about this.

Here is some further weirdness.

I define a function to return +1 or -1 according to whether the input is an odd or even multiple of 10. This function tests the parity in two ways, one by seeing whether the number is 1 modulo 2, and one using the OddQ function.

func[t_] := Module[{},
  {If[Mod[Floor[t/10], 2] == 1, 1, -1], If[OddQ[Floor[t/10]], 1, -1]}
  ]

Obviously, both return values should be the same, and indeed this is the case. E.g.

{func[11], func[23], func[35]}

gives

{{1, 1}, {-1, -1}, {1, 1}}

as expected.

I now use this in my differential equation. Firstly, I take the first part of the return value of func, i.e.

soln = NDSolve[{x'[t] == func[t][[1]], x[0] == 0}, x, {t, 0, 100}];
Plot[x[t] /. soln, {t, 0, 100}]

This gives a sawtooth as expected:

Next, I take the second part of the return value of func, i.e.

soln = NDSolve[{x'[t] == func[t][[2]], x[0] == 0}, x, {t, 0, 100}];
Plot[x[t] /. soln, {t, 0, 100}]

This gives a monotonic decline as previously:

This makes no sense. The first and second parts of the return value from func are exactly the same, as shown above. How come Mathematica knows that the second part was calculated from OddQ and treats it differently, somehow ignoring the actual value and substituting a constant value?

Thank you very much. I also found that testing the remainder mod 2 works, see my other post, and it's weird that Mathematica can distinguish between two things that ought to be a pure number--both came from If statements but one of them used OddQ...and Mathematica somehow doesn't like that one. What's more, if you plot the number directly, it behaves normally, but if you use it in a differential equation, Mathematica ignores the fact it is changing.

Of course, this isn't really what I was interested in or trying to do. I was trying to understand why, when a variable changed value in my set of coupled differential equations, it didn't affect the behaviour of the other variable even though the other variable's differential equation depended on it. So I hard-wired in this switching behaviour and found that that had no effect either. Now I find that it does have an effect provided I use the test Mod[u,2]==1 and not OddQ[u], even though those should be equivalent.