[client] Reconnect management and signal promptly after a network change

Three pieces, each verified on Android across WiFi/cellular switches:

- A sweep-aware backoff wrapper: the first retry after a disconnect
  that follows a recent network-change mark comes after 200ms instead
  of the randomized [0..1.6s] interval. Any other failure keeps the
  unchanged spread, so the clients of a restarted server still scatter
  their reconnects.
- The retry sleep wakes on OS network availability transitions
  (nbgrpc.Retry): a disconnect that precedes the offline flag by a few
  milliseconds no longer sleeps blindly through the recovery - the
  loop parks on the netstate gate and resumes the moment the network
  returns.
- The connection state is re-checked after WaitForStateChange: a dial
  settling in Ready proceeds immediately instead of burning another
  backoff round on an already-usable channel.

Measured after a network switch: management and signal recover in
270-470ms deterministically, down from a 312-1593ms lottery.

client/netsweep/netsweep.go

@@ -13,13 +13,18 @@ import (
 	"sync"
 	"time"
 
+	"github.com/cenkalti/backoff/v4"
 	log "github.com/sirupsen/logrus"
+
+	"github.com/netbirdio/netbird/client/netstate"
 )
 
 // DefaultSweepDelay absorbs network flapping while the OS settles on a
 // default network before the stale registrations are cut.
 const DefaultSweepDelay = 500 * time.Millisecond
 
+const recentMarkWindow = 3 * time.Second
+
 // Config customizes a Sweeper. The zero value applies the defaults.
 type Config struct {
 	// SweepDelay overrides DefaultSweepDelay when positive.
@@ -96,6 +101,7 @@ type Sweeper struct {
 	gen        uint64
 	timer      *time.Timer
 	sweepDelay time.Duration
+	lastMark   time.Time
 }
 
 // New creates an empty sweeper with the default configuration.
@@ -179,6 +185,7 @@ func (s *Sweeper) MarkNetworkChange() {
 	s.mu.Lock()
 	s.gen++
 	cutoff := s.gen
+	s.lastMark = time.Now()
 	if s.timer != nil {
 		s.timer.Stop()
 	}
@@ -189,6 +196,27 @@ func (s *Sweeper) MarkNetworkChange() {
 	s.mu.Unlock()
 }
 
+// QuickRetryBackoff wraps bo so that after each Reset the first retry comes
+// quickly when the disconnect followed a recent network change and the
+// network is online. Any other failure keeps bo's spread, so the clients of
+// a restarted server still scatter their reconnects. A nil sweeper returns
+// bo unchanged.
+func (s *Sweeper) QuickRetryBackoff(ctx context.Context, bo backoff.BackOff, netState *netstate.State) backoff.BackOff {
+	if s == nil {
+		return bo
+	}
+	return backoff.WithContext(newQuickRetryBackoff(bo, s, netState), ctx)
+}
+
+func (s *Sweeper) markedRecently() bool {
+	if s == nil {
+		return false
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return !s.lastMark.IsZero() && time.Since(s.lastMark) < recentMarkWindow
+}
+
 // sweep closes the registered connections and aborts the in-flight dials
 // older than cutoff, and returns how many connections it closed. A dial
 // whose connection was not yet handed to WrapConn is marked, so the late