v3: create separate mock for Watcher interface

[bigbes]

We need a dedicated, reusable mock implementation of the tarantool.Watcher
interface to enable reliable and isolated unit testing for components that
depend on watch events.

The real Watcher typically works by calling a user-provided callback
(WatchCallback) whenever a new WatchEvent is received from Tarantool.
In tests, we want to simulate this behavior without connecting to a real
instance.

Suggested Approaches (choose one or combine ideas)

1. Channel-based event source

   The mock accepts a <-chan *tarantool.WatchEvent at creation.
   Internally, it reads from this channel and invokes the callback
   for each event. This mimics a live stream of updates.

   ch := make(chan *tarantool.WatchEvent)
   mockW := mock.NewWatcher(ch)
   mockW.Watch(ctx, "mykey", func(ev *tarantool.WatchEvent) {
       // handle event
   })
   ch <- &tarantool.WatchEvent{Key: "mykey", Data: []byte("updated")}
   close(ch) // optional: signal end

2. Preloaded event list

   The mock is initialized with a fixed slice of events. When Watch()
   is called, it immediately (or after a trigger) replays all events
   through the callback.

   events := []*tarantool.WatchEvent{
       {Key: "foo", Data: []byte("v1")},
       {Key: "foo", Data: []byte("v2")},
   }
   mockW := mock.NewWatcherWithEvents(events...)
   
   mockW.NewWatcher("foo", cb)
   // all events are delivered synchronously or via a controlled tick

3. Manual event injection

   Expose a method like Send(*WatchEvent) so tests can push events on demand:

   mockW := mock.NewWatcher()
   mockW.Watch(ctx, "bar", cb)
   mockW.Send(&tarantool.WatchEvent{Key: "bar", Data: []byte("hello")})

Choose the design that offers the best balance of simplicity and flexibility.
If unsure, the manual Send() approach is often the most test-friendly and
easiest to reason about.