feat(glue): pull the caller from the host image and push it across the C ABI

Everything under this has merged — the protocol resolves the caller and
opens a scope (#70), both backends define logos_module_set_call_caller
(cpp-sdk #147, rust-sdk #47) — and nothing connected the two, so
currentCaller() returned Unknown everywhere. This is the wire.

Per dispatch, all on the dispatch thread: pull the caller document back out
of the HOST image, push it into the module image, dispatch, pop.

WHY THE PULL IS AN invokeMethod AND NOT A CALL
The host binary and the module plugin EACH define LogosAPI — meta-object
included — with their own statics at distinct addresses and no undefined
reference to the other's. Mach-O is TWOLEVEL, PE has no interposition. A
direct logosAPI()->currentCallerJson() binds to the PLUGIN copy and reads
the PLUGIN thread-local: empty, forever, silently, on macOS and Windows.
invokeMethod resolves through metaObject()/qt_metacall, which are virtual
and whose vptr the HOST constructor wrote, so it lands in host code on the
calling thread. Same channel initLogos and aboutToUnload already use.

IN MULTI THE PULL IS BEFORE THE CAPTURE
callMethod is entered on the dispatch thread and captures by value into
QThread::create, so the pull happens there and the JSON rides along; the
push/pop triple moves verbatim into the worker. Pulling inside the worker
also compiles, and every multi call would read Unknown because that thread
never had a scope. A test asserts the source ORDER, and it was driven red
by making exactly that mistake.

The invokable's name was not chosen here: logos-protocol master already
names currentCallerJson in three places, including a CMakeLists comment
saying the header ships so this file can answer it.

Two checks beyond the wire, because the by-name test alone left gaps:

  * test-glue-compiles — NOTHING in this repo compiled the emitted glue.
    test-qt-host-generator.cpp documents a bug that escaped through exactly
    that hole. Both branches now build as a real Qt plugin with the C ABI
    stubbed and -Wl,--no-undefined, so a missing symbol fails at link
    rather than at a user's dlopen.
  * test-caller-invokable — six runtime assertions, including that a scope
    open on one thread is INVISIBLE on another, which is the actual
    justification for the multi placement.

The contract test strips comments before its negative assertions (both
files legitimately NAME the forbidden calls in prose) and guards that with
a positive control, so the negatives cannot pass vacuously.

Guard is MAJOR-aware expanded arithmetic. Dropping only the MAJOR > 0 arm
still passes a grep, so the test resolves at 1.0 and asserts the call
survives; that mutation was driven red too.

11 checks green on x86_64-linux, the three new ones green on
aarch64-darwin, and the Windows mingw cross builds.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

cpp/logos_api.cpp

@@ -3,10 +3,25 @@
 #include "logos_api_provider.h"
 #include "logos_thread_marshal.h"
 #include "token_manager.h"
+// For LOGOS_PROTOCOL_VERSION_{MAJOR,MINOR}, which currentCallerJson()'s body is
+// guarded on. Included by name rather than relied on transitively: if the macro
+// were merely undefined here the guard would evaluate FALSE and this file would
+// still compile, handing every module a permanently empty caller with no
+// diagnostic anywhere.
+#include "logos_protocol.h"
 #include <QDebug>
 #include <QVariant>
 #include <string>
 
+// The host half of the caller: logos::currentInboundCallerJson() and
+// logos::callerUnknownJson(). Arrived in logos-protocol 0.6, so the include is
+// guarded exactly as the body below is — this file must keep compiling against
+// an older protocol, where the header does not exist.
+#if defined(LOGOS_PROTOCOL_VERSION_MINOR) && (LOGOS_PROTOCOL_VERSION_MAJOR > 0 || \
+    (LOGOS_PROTOCOL_VERSION_MAJOR == 0 && LOGOS_PROTOCOL_VERSION_MINOR >= 6))
+#include "logos_caller_scope.h"
+#endif
+
 LogosAPI::LogosAPI(const QString& module_name, QObject *parent)
     : LogosAPI(module_name, LogosTransportSet{}, parent)
 {
@@ -70,6 +85,30 @@ LogosAPI::~LogosAPI()
 
 }
 
+// See logos_api.h for WHY this exists as an invokable rather than a plain
+// method or a property. The body is one line of substance; the mechanism is
+// entirely in how it is REACHED.
+//
+// The DECLARATION stays unguarded even though the body is guarded, matching
+// aboutToUnload in the generated glue: moc emits the meta-object entry either
+// way, and a by-name lookup should find the same surface on every host. On a
+// protocol below 0.6 the answer is an empty QString — not a hand-spelled
+// unknown document, because at that version the whole surface is absent
+// (nothing on the module side can receive one, since the glue's push is guarded
+// on the same expression) and inventing a second spelling of
+// logos::callerUnknownJson() here is exactly how the two would drift apart.
+QString LogosAPI::currentCallerJson() const
+{
+#if defined(LOGOS_PROTOCOL_VERSION_MINOR) && (LOGOS_PROTOCOL_VERSION_MAJOR > 0 || \
+    (LOGOS_PROTOCOL_VERSION_MAJOR == 0 && LOGOS_PROTOCOL_VERSION_MINOR >= 6))
+    const std::string caller = logos::currentInboundCallerJson();
+    return QString::fromStdString(caller.empty() ? logos::callerUnknownJson()
+                                                 : caller);
+#else
+    return QString();
+#endif
+}
+
 LogosAPIProvider* LogosAPI::getProvider() const
 {
     return m_provider;