Remove VVV_min/max in favor of SDL_min/max

VVV_min/max are functions that only operate on ints, and SDL_min/max are
macros that operate on any type but double-evaluate everything.

I know I more-or-less said earlier that SDL_min/max were dumb but I've
changed my mind and think it's better to use them, taking care to make
sure you don't double-evaluate, rather than trying to generate your own
litany of functions with either your own hand-rolled generation macros,
C++ templates, C11 generics, or GCC extensions (that last one you'd
technically use in a macro but it doesn't really matter), all of which
have more downsides than just not double-evaluating.

And the upside of not double-evaluating is that you're disencouraged
from having really complicated single-line min/max expressions and
encouraged to precompute the values beforehand anyway so the final
min/max is more readable. And furthermore you'll notice when you
yourself end up doing double-evaluations anyway. I removed a couple
instances of Graphics::len() being double-evaluated in this commit (as
well as cleaned up some other min/max-using code). Although the only
downside to those double-evaluations was unnecessary computation,
rather than checking the wrong result or having multiple side effects,
thankfully, it's still good to minimize double-evaluations where
possible.

desktop_version/src/UtilityClass.cpp

@@ -122,7 +122,7 @@ bool next_split_s(
         /* Using SDL_strlcpy() here results in calling SDL_strlen() */
         /* on the whole string, which results in a visible freeze */
         /* if it's a very large string */
-        const size_t length = VVV_min(buffer_size - 1, len);
+        const size_t length = SDL_min(buffer_size - 1, len);
         SDL_memcpy(buffer, &str[prev_start], length);
         buffer[length] = '\0';
     }
@@ -344,6 +344,6 @@ void _VVV_between(
     SDL_strlcpy(
         middle,
         &original[left_length],
-        VVV_min(middle_length + 1, middle_size)
+        SDL_min(middle_length + 1, middle_size)
     );
 }