feat!: make Logger a value type with a public ILogger sink

[andiwand]

🤖 Generated with Claude Code

Clears the first of the two Breaking API changes (next major) items in
docs/design/README.md, ahead of the v6 tag.

Why

Logger was the one public interface type that was not a value handle. It was an
abstract base handed out as Logger & or std::shared_ptr<Logger>, and the two
spellings had drifted apart across the API:

header	took
file.hpp, odr.hpp	Logger &logger = Logger::null()
html.hpp, http_server.hpp	std::shared_ptr<Logger> logger = Logger::create_null()

What

The sink becomes odr::ILogger and Logger becomes a copyable handle over a
shared_ptr to it, mirroring File, DecodedFile and Document (including the
impl() accessor). Both spellings collapse into a single const Logger &,
defaulted to Logger::null().

ILogger lives in the public header rather than internal::abstract. Routing
diagnostics somewhere is a thing a library user legitimately wants to do, and an
extension point that requires including an internal header is not one.

Parsers that held a borrowed const Logger *m_logger{nullptr} now hold a Logger
by value, so a logger outliving its parser stops being the caller's problem.

Bindings can implement a sink too

Both bindings previously dropped Logger entirely. Now:

class MySink(pyodr.ILogger):
    def will_log(self, level):  return level >= pyodr.LogLevel.warning
    def log(self, time, level, message, location): ...
    def flush(self): ...

pyodr.open(path, logger=pyodr.Logger(MySink()))

try (Logger logger = new Logger(mySink);
     DecodedFile file = Odr.open(path, logger)) { ... }

Entry points that take a logger in C++ gained an optional logger argument.

Two teardown traps the Python trampoline had to work around — both invisible to a
happy-path test, and both hit while writing this:

• The sink is handed to C++ as a shared_ptr owning a reference to the Python
  object. Without it, Logger(MySink()) leaves C++ holding a dead object and the
  next call dies with Tried to call pure virtual function.
• flush() dispatches via py::get_override, not PYBIND11_OVERRIDE_PURE. Sinks
  are flushed from destructors, which can run after the Python object is gone, and
  throwing from a destructor aborts the process.

On the Java side JavaLogger attaches/detaches the calling thread (log calls
arrive on whatever thread the library is working on) and clears any exception the
sink throws rather than leaving it pending — a logger must not derail the
operation it is reporting on.

ILogger::log is non-const

std::ostream is the precedent and it argues the same way: operator<<, write,
put and flush are non-const, while good/fail/rdstate are const. Writing
mutates the sink.

The old const was also vacuous — *m_output on a const std::unique_ptr yields
a non-const std::ostream &, so StdioLogger mutated freely from a const method.
All it achieved was forcing implementations to declare their state mutable, as
the test sink in logger_test.cpp had to before this. will_log stays const; it
is a genuine query.

The handle's log()/flush() remain const — const handle, mutable sink, exactly
like shared_ptr. That is what lets every API take const Logger &.

Breaking changes

• Logger is final; custom sinks implement odr::ILogger and are wrapped with
  Logger(std::shared_ptr<ILogger>).
• Logger::null() returns a Logger by value instead of Logger &.
• Logger::create_null() is gone — use Logger::null(). All instances share one
  sink, so it no longer allocates.
• create_stdio returns Logger, not std::unique_ptr<Logger>.
• create_tee returns Logger and takes const std::vector<Logger> &.
• Every API taking Logger & or std::shared_ptr<Logger> now takes const Logger &.

The ODR_* macros are unchanged; call sites just drop the *
(ODR_INFO(*logger, …) → ODR_INFO(logger, …)).

TeeLogger no longer flushes its children from its destructor. It was redundant —
each child handle drops its sink on destruction and a buffering sink flushes
itself — and it was the path that called into an already-torn-down Python sink.

Test plan

• logger_test.cpp went from one smoke test to nine, covering what the value
  semantics newly promise: copies share the sink, the default handle is the null
  logger, level filtering, tee fan-out, empty-tee throw, a null sink rejected, and
  an out-of-library ILogger driven through the handle and through a tee.
• Full C++ suite (excluding the slow HTML-output regression): 466 passed.
• Python: 41 passed, incl. a new test_logger.py implementing a sink in Python.
• JNI: 31 passed, incl. a new LoggerTest implementing a sink in Java and
  passing it to Odr.open.