Add WatchEvents, enable/disable/weight RPCs, and config check

gRPC / proto
- Rename WatchBackendEvents → WatchEvents; return a stream of Event
  oneof (LogEvent, BackendEvent, FrontendEvent) with optional filter
  flags (log, log_level, backend, frontend)
- Add EnableBackend, DisableBackend, SetFrontendPoolBackendWeight RPCs
- Rename PauseResumeRequest → BackendRequest
- Add CheckConfig RPC returning ok/parse_error/semantic_error

maglevd
- Route slog through a LogBroadcaster (slog.Handler) so WatchEvents
  subscribers can receive structured log records independently of the
  daemon's own --log-level
- Add --reflection flag (default true) to toggle gRPC server reflection
- Add --check flag: validates config file and exits 0/1/2
- SIGHUP: use config.Check before applying reload; log parse vs semantic
  error separately; refuse reload on any error
- Rename default config path /etc/maglev → /etc/vpp-maglev

maglevc
- Add 'watch events [num <n>] [log [level <level>]] [backend] [frontend]'
  command; prints compact protojson, stops on any keypress or Ctrl-C;
  uses cbreak mode (not raw) so output post-processing is preserved
- Add 'set backend <name> enable|disable'
- Add 'set frontend <name> pool <pool> backend <name> weight <0-100>'
- Add 'config check' command

Debian packaging
- Rename service unit to vpp-maglevd.service
- Rename conffiles to /etc/default/vpp-maglev and /etc/vpp-maglev/
- Create maglevd system user/group in postinst; add to vpp group if present
- Add postrm; add adduser to Depends

internal/checker/checker_test.go

@@ -246,6 +246,98 @@ func TestSubscribe(t *testing.T) {
 	}
 }
 
+func TestSetFrontendPoolBackendWeight(t *testing.T) {
+	cfg := makeTestConfig(time.Hour, 3, 2)
+	c := New(cfg)
+
+	// Valid weight change.
+	fe, err := c.SetFrontendPoolBackendWeight("web", "primary", "be0", 42)
+	if err != nil {
+		t.Fatalf("SetFrontendPoolBackendWeight: %v", err)
+	}
+	if fe.Pools[0].Backends["be0"].Weight != 42 {
+		t.Errorf("weight: got %d, want 42", fe.Pools[0].Backends["be0"].Weight)
+	}
+	// Persisted in live config.
+	got, _ := c.GetFrontend("web")
+	if got.Pools[0].Backends["be0"].Weight != 42 {
+		t.Errorf("config weight: got %d, want 42", got.Pools[0].Backends["be0"].Weight)
+	}
+
+	// Out-of-range weight.
+	if _, err := c.SetFrontendPoolBackendWeight("web", "primary", "be0", 101); err == nil {
+		t.Error("expected error for weight 101")
+	}
+
+	// Unknown frontend.
+	if _, err := c.SetFrontendPoolBackendWeight("nope", "primary", "be0", 50); err == nil {
+		t.Error("expected error for unknown frontend")
+	}
+
+	// Unknown pool.
+	if _, err := c.SetFrontendPoolBackendWeight("web", "nope", "be0", 50); err == nil {
+		t.Error("expected error for unknown pool")
+	}
+
+	// Unknown backend.
+	if _, err := c.SetFrontendPoolBackendWeight("web", "primary", "nope", 50); err == nil {
+		t.Error("expected error for unknown backend in pool")
+	}
+}
+
+func TestEnableDisable(t *testing.T) {
+	cfg := makeTestConfig(time.Hour, 3, 2)
+	c := New(cfg)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	go c.fanOut(ctx)
+
+	// Seed a worker as EnableBackend/DisableBackend require one in c.workers.
+	wCtx, wCancel := context.WithCancel(ctx)
+	c.mu.Lock()
+	c.runCtx = ctx
+	c.workers["be0"] = &worker{
+		backend: health.New("be0", net.ParseIP("10.0.0.2"), 2, 3),
+		hc:      cfg.HealthChecks["icmp"],
+		entry:   cfg.Backends["be0"],
+		cancel:  wCancel,
+	}
+	c.mu.Unlock()
+	_ = wCtx
+
+	b, ok := c.DisableBackend("be0")
+	if !ok {
+		t.Fatal("DisableBackend: not found")
+	}
+	if b.Health.State != health.StateRemoved {
+		t.Errorf("after disable: state=%s, want removed", b.Health.State)
+	}
+	if b.Config.Enabled {
+		t.Error("after disable: Enabled should be false")
+	}
+
+	// Backend should still be visible after disable.
+	snap, ok := c.GetBackend("be0")
+	if !ok {
+		t.Fatal("GetBackend after disable: not found")
+	}
+	if snap.Config.Enabled {
+		t.Error("GetBackend after disable: Enabled should be false")
+	}
+
+	b, ok = c.EnableBackend("be0")
+	if !ok {
+		t.Fatal("EnableBackend: not found")
+	}
+	if b.Health.State != health.StateUnknown {
+		t.Errorf("after enable: state=%s, want unknown", b.Health.State)
+	}
+	if !b.Config.Enabled {
+		t.Error("after enable: Enabled should be true")
+	}
+}
+
 func TestPauseResume(t *testing.T) {
 	cfg := makeTestConfig(time.Hour, 3, 2)
 	c := New(cfg)