…ice.createAgentTool`

Refs JetBrains#873

…oll back tool calls with side effects when checkpointing. Make `AIAgent` state-manageable and introduce `AIAgentService` to manage multiple uniform running agents. Deprecate concurrent unsafe `AIAgent.asTool` in favor of `AIAgentService.createAgentTool` (JetBrains#873)

1. Add `RollbackToolRegistry` in the `Persistency` feature in order to
roll back tool calls with side effects when checkpointing:

```kotlin
val agent = AIAgent(
    toolRegistry = ToolRegistry {
        tool(::createUser)
        tool(::sendMessage)
        tool(::inviteMember)
    },
    ...
) {
    install(Persistency) {
        storage = myStateStorageImpl
    
        rollbackToolRegistry = RollbackToolRegistry {
            // TOOL -> "REVERSE" TOOL
            
            registerRollback(::createUser, ::deleteUser)
            registerRollback(::sendMessage, ::undoMessage)
            registerRollback(::inviteMember, ::revokeInvitation)
        }
    }
}
```

2. Now you can also manage (create, run, find, access running state)
multiple AI Agents using `AIAgentService` :

```kotlin
val agentService = AIAgentService(
    toolRegistry = ToolRegistry {
        tool(::createUser)
        tool(::sendMessage)
        tool(::inviteMember)
    },
    ...
) {
    install(Persistency) {
        storage = myStateStorageImpl
    
        rollbackToolRegistry = RollbackToolRegistry {
            registerRollback(::createUser, ::deleteUser)
            registerRollback(::sendMessage, ::undoMessage)
            registerRollback(::inviteMember, ::revokeInvitation)
        }
    }
}
```

And then you can create instances of AIAgent, and manage their running
state. This is particularly useful to rollback long-running operations
if user realizes that agent took the wrong direction:

```kotlin
// user creates new agent:
post("/agent") {
    val input = call.receive<String>()

    val agent = agentService.createAgent()

    launch {
        agent.run(input
    }
    
    call.respond(agent.id)
}

// user checks the agent's state:
get("/agent") {
    val id = call.receive<String>()
    val agent = agentService.agentById(id)

    if (!agent.finished()) call.respondText("Agent is still running...")
    else call.respond(agent.resultIfReady()!!)
}

// user asks running agent to rollback:
data class RollbackRequest(val agentId: String, val checkpoint: String)

put("/agent/rollback") {
    val userRequest = call.receive<RollbackRequest>()
    val agent = agentService.agentById(userRequest.agentId)

    if (agent.finished()) {
         call.respondText("Agent has already finished!")
    } else {
        // Rolling back agent to a checkpoint
        agent.withRunningContext {
            withPersistency(this) { ctx ->
                rollbackToCheckpoint(userRequest.checkpoint, ctx)
            }
        }
    
        call.respond(HttpStatusCode.OK)
    }
}
```

3. Make `AIAgent` explicitly single-run. Previous semantic was:
`AIAgent.run` can be called multiple times, but if called in parallel --
throws exception that agent is currently running.
This was creating a hard to manage contract for `run()` and was very
error-prone (see example of such errors below in `4`)

4. Fix `Agent.asTool` for parallel use
JetBrains#864 . Previously --
`AIAgentTool` was holding an instance of `AIAgent` and running it. When
LLM decided to call tools in parallel, because of the previous contract
of `AIAgent` it was failing in runtime with exception. Hence,
`AIAgent.asTool` was broken.
Now -- intended usage is `AIAgentService.createAgentTool()`.
`AIAgent.asTool` is now deprecated and is currently working correctly
via `AIAgentService.fromAgent(this).createAgentTool()` (i.e. it creates
an instance of `AIAgentService` from the current `AIAgent`, then creates
a tool that holds a new copy of `AIAgent`).

## Motivation and Context
<!-- Why is this change needed? What problem does it solve? -->

## Breaking Changes
<!-- Will users need to update their code or configurations? -->

---

#### Type of the changes
- [x] New feature (non-breaking change which adds functionality)
- [ ] Bug fix (non-breaking change which fixes an issue)
- [ ] Breaking change (fix or feature that would cause existing
functionality to change)
- [ ] Documentation update
- [ ] Tests improvement
- [ ] Refactoring

#### Checklist
- [x] The pull request has a description of the proposed change
- [x] I read the [Contributing
Guidelines](https://github.com/JetBrains/koog/blob/main/CONTRIBUTING.md)
before opening the pull request
- [x] The pull request uses **`develop`** as the base branch
- [x] Tests for the changes have been added
- [ ] All new and existing tests passed

##### Additional steps for pull requests adding a new feature
- [ ] An issue describing the proposed change exists
- [ ] The pull request includes a link to the issue
- [ ] The change was discussed and approved in the issue
- [x] Docs have been added / updated