Many years ago, working on the VisualDSolve package, I needed a FindAllRoots function, and also a FindAllRoots2D for 2x2 systems. My algorithm for the latter is cool -- making use of the data that ContourPlot provides us. But it does have difficulty with tangential roots. In 1 dimension a subdivision process leads to an algorithm, but again, tangential roots are a problem. Note also that Interval Arithmetic can be used, and such is included in Mathematica. E.g., an interval arithmetic approach to Problem 4 of the SIAM 100-Digit Challenge (WRI had a team, and I was on a Macalester College team) found 1000 or more roots of a complicated f(x,y) in a rectangle (and proved that they were all found; details in The SIAM 100-Digit Challenge book). Such an approach would work in 1 dimension as well (tangencies aside), and provide a proof of completeness. "Interval root-finding" its a well-studied field.

I think the following is a cute approach, but it's not very efficient:

Solve[0 == 
  DSolveValue[{y'[x] == 
     D[Piecewise[{{t[x] Log[2 - t[x]], 
         0 <= t[x] < 1}}, (t[x] - 2) Log[t[x]]], t[x]], y[0] == 0,
    t'[x] == 1, t[0] == 0,
    WhenEvent[Mod[x, 2] == 0, t[x] -> t[x] - 2]},
   y[x], {x, 0, 100},
   Method -> {"Events", "MaxEvents" -> 1020} (*not needed unless x goes past 2000*)
   ],
 x
 ]
(*
{{x -> 0}, {x -> 2}, {x -> 4}, {x -> 6}, {x -> 8}, {x -> 10},
 {x -> 12}, {x -> 14}, {x -> 16}, {x -> 18}, {x -> 20},
 {x -> 22}, {x -> 24}, {x -> 26}, {x -> 28}, {x -> 30},
 {x -> 32}, {x -> 34}, {x -> 36}, {x -> 38}, {x -> 40},
 {x -> 42}, {x -> 44}, {x -> 46}, {x -> 48}, {x -> 50},
 {x -> 52}, {x -> 54}, {x -> 56}, {x -> 58}, {x -> 60},
 {x -> 62}, {x -> 64}, {x -> 66}, {x -> 68}, {x -> 70},
 {x -> 72}, {x -> 74}, {x -> 76}, {x -> 78}, {x -> 80},
 {x -> 82}, {x -> 84}, {x -> 86}, {x -> 88}, {x -> 90},
 {x -> 92}, {x -> 94}, {x -> 96}, {x -> 98}, {x -> 100}}
*)

It takes almost 5 seconds. The full 2026 takes 86 seconds (Macbook Pro M4 Max).

For some reason, WRI often plays method option values close to the chest.

If you think plotting is "easy," then here's a plot-based approach:

pl = Plot[f[x], {x, -0.01, 10.01}];
pts = First@Cases[pl, Line[p_] :> p, Infinity];
brackets = (* find intervals where plot crosses x axis *)
  Extract[#, {{1, 2}, {2, 1}}] & /@ 
   Partition[SplitBy[pts, Sign@*Last][[All, {1, -1}, 1]], 2, 1];
FindRoot[f[x], {x, ##}, Method -> "Brent", (* polishes estimates from plot *)
   AccuracyGoal -> 50] & @@@ brackets
(*
{{x -> 0.}, {x -> 1.}, {x -> 2.}, {x -> 3.}, {x -> 4.}, {x -> 
   5.}, {x -> 6.}, {x -> 7.}, {x -> 8.}, {x -> 9.}, {x -> 10.}}
*)

These internal functions do something similar. I don't know where the following functions are used internally or why they don't seem available in some System` level solver:

ClearAll[f];
f[x_] := x Log[2 - x] /; 0 <= x < 1
f[x_] := (x - 2) Log[x] /; 1 <= x <= 2
f[x_] := -f[-x] /; x < 0
f[x_] := f[x - 2] /; x > 2

With[{a = 0, b = 10,
  opts = Options[Visualization`Core`Plot]},
 WithCleanup[
  SetOptions[Visualization`Core`Plot, PlotPoints -> 2 b, 
   MaxRecursion -> 1],
  System`TRootsDump`GuessesToRoots[
    f,
    System`TRootsDump`GuessRealRoots[f, {a, b}],
    {a, b}, All, MachinePrecision][[All, 1]],
  SetOptions[Visualization`Core`Plot, opts]
  ]
 ]
(*  {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}  *)

For b = 2026, it takes about 85 seconds.

Thank you very much. Rewriting the functional form via alternative methods allows its solutions to be found effortlessly.

Thank you very much; this gives an excellent account of why this issue arises.