feat(#984): Swarm — ServiceLoader-based agent discovery + absorb

[Skobeltsyn]

A captain agent discovers sibling agent JARs on its classpath and absorbs their full Agent<*, *> surfaces as tools, preserving each sibling's personality (prompt, skills, knowledge, memory, observability hooks, error handlers).

API:

// Each sibling JAR ships:
//   META-INF/services/agents_engine.runtime.AgentProvider
// pointing at:
interface AgentProvider {
    fun build(): Agent<*, *>
}

// Captain main():
fun main(args: Array<String>) {
    val me = agent<String, String>("captain") { ... }
    Swarm.discover()
        .filterNot { it.name == me.name }
        .forEach { sibling -> me.absorb(sibling) }
    LiveRunner.serve(me, args)
}

In-JVM only — siblings live in the same classloader as the captain, so the framework's typed Agent contract reaches them directly. No serialization across JAR boundaries, no IPC overhead. Cross-language remains MCP-stdio's job (separate ticket).

absorb:

• registers a tool named after the sibling agent
• the tool's executor calls sibling.invoke(query)
• auto-enables the tool across all of the captain's skills
• requires sibling to be Agent<String, *>; typed-input siblings throw IllegalArgumentException with a clear message
• forbids absorbing self (collision against captain's own name)
• forbids two siblings with the same name (collision in toolMap)

Tests, TDD red first:

SwarmTest (9 tests):
- AgentProvider is a real interface
- Swarm.discover(emptyClassLoader) finds nothing
- Swarm.discover() finds the in-test fixture provider via META-INF/services
- absorb adds a tool named after the sibling
- absorbed tool delegates to sibling and returns its output
- two same-name siblings → second absorb fails fast
- cannot absorb self
- typed-input sibling fails fast with helpful error
- absorbed tool is auto-available across captain's skills

SwarmJarIntegrationTest (1 end-to-end test):
- writes a real Java AgentProvider source to a temp dir
- compiles via javax.tools.JavaCompiler (always present in JDK)
- packs into a real JAR with manifest + META-INF/services
- URLClassLoader over the JAR with the test classpath as parent
- Swarm.discover(loader) finds the sibling
- sibling.invoke("hello") returns "from-jar:hello" — proves the JAR-loaded code path is end-to-end functional, not just a name on a list
- captain.absorb(sibling); the absorbed tool reaches the JAR-loaded sibling correctly

The integration test relies on the JDK's bundled JavaCompiler — no extra Gradle dependency. Provider source is Java (not Kotlin) to avoid pulling kotlin-compiler-embeddable into the test JVM.