[clang-tidy] Improve documentation for modernize-use-std-print check

[mikecrowe]

Summary

Remove incorrect use of double colons so that the code blocks are
rendered correctly to HTML.

Wrap the name of another check in single backticks. Wrap the name of a
macro in double backticks.

Explain that with the default settings the check is only enabled with
C++23 or later standards.

Correct std::string_data() to std::string::data().

clang-tools-extra/docs/clang-tidy/checks/modernize/use-std-print.rst

 .. title:: clang-tidy - modernize-use-std-print
 
 modernize-use-std-print
 =======================
 
 Converts calls to ``printf``, ``fprintf``, ``absl::PrintF`` and
 ``absl::FPrintf`` to equivalent calls to C++23's ``std::print`` or
 ``std::println`` as appropriate, modifying the format string appropriately.
 The replaced and replacement functions can be customised by configuration
 options. Each argument that is the result of a call to ``std::string::c_str()`` and
 ``std::string::data()`` will have that now-unnecessary call removed in a
-similar manner to the readability-redundant-string-cstr check.
+similar manner to the `readability-redundant-string-cstr` check.
 
-In other words, it turns lines like::
+In other words, it turns lines like:
 
 .. code-block:: c++
 
   fprintf(stderr, "The %s is %3d\n", description.c_str(), value);
 
-into::
+into:
 
 .. code-block:: c++
 
   std::println(stderr, "The {} is {:3}", description, value);
 
-It doesn't do a bad job, but it's not perfect. In particular:
+If the `ReplacementPrintFunction` or `ReplacementPrintlnFunction` options
+are left, or assigned to their default values then this check is only
+enabled with `-std=c++23` or later.
+
+The check doesn't do a bad job, but it's not perfect. In particular:
 
 - It assumes that the format string is correct for the arguments. If you
   get any warnings when compiling with `-Wformat` then misbehaviour is
   possible.
 
 - At the point that the check runs, the AST contains a single
   ``StringLiteral`` for the format string and any macro expansion, token
   pasting, adjacent string literal concatenation and escaping has been
   handled. Although it's possible for the check to automatically put the
   escapes back, they may not be exactly as they were written (e.g.
   ``"\x0a"`` will become ``"\n"`` and ``"ab" "cd"`` will become
-  ``"abcd"``.) This is helpful since it means that the PRIx macros from
+  ``"abcd"``.) This is helpful since it means that the ``PRIx`` macros from
   ``<inttypes.h>`` are removed correctly.
 
 - It supports field widths, precision, positional arguments, leading zeros,
   leading ``+``, alignment and alternative forms.
 
 - Use of any unsupported flags or specifiers will cause the entire
   statement to be left alone and a warning to be emitted. Particular
   unsupported features are:
- any arguments that corresponded to ``%p`` specifiers that
   to ``const void *``.
 - any arguments that corresponded to ``%s`` specifiers where the argument
   is of ``signed char`` or ``unsigned char`` type are wrapped in a
   ``reinterpret_cast<const char *>``.
 - any arguments where the format string and the parameter differ in
   signedness will be wrapped in an approprate ``static_cast`` if `StrictMode`
   is enabled.
 - any arguments that end in a call to ``std::string::c_str()`` or
-  ``std::string_data()`` will have that call removed.
+  ``std::string::data()`` will have that call removed.
 
 Options
 -------
 
 .. option:: StrictMode
 
    When `true`, the check will add casts when converting from variadic
    functions like ``printf`` and printing signed or unsigned integer types
    (including fixed-width integer types from ``<cstdint>``, ``ptrdiff_t``,
    ``size_t`` and ``ssize_t``) as the opposite signedness to ensure that
    the output matches that of ``printf``. This does not apply when
    converting from non-variadic functions such as ``absl::PrintF`` and
    ``fmt::printf``. For example, with `StrictMode` enabled:
 
   .. code-block:: c++
 
     int i = -42;
     unsigned int u = 0xffffffff;
     printf("%d %u\n", i, u);
 
-  would be converted to::
+  would be converted to:
 
   .. code-block:: c++
 
     std::print("{} {}\n", static_cast<unsigned int>(i), static_cast<int>(u));
 
   to ensure that the output will continue to be the unsigned representation
   of `-42` and the signed representation of `0xffffffff` (often
   `4294967254` and `-1` respectively.) When `false` (which is the default),