fix: reduce sync worker ticker period to 5m to prevent threshold drift at minimum sync interval (#4023)

## Summary

The sync worker ticker period was set to 1 hour, which created a subtle scheduling bug: when `pricingSyncInterval` is set near the minimum supported value, the few seconds a sync takes to complete causes the next ticker wake-up to land just under the elapsed-time threshold, effectively doubling the actual sync cadence. Reducing the ticker period to 5 minutes ensures the check granularity stays well below the minimum supported `pricingSyncInterval`, preventing ticker drift from defeating the threshold check.

## Changes

- Reduced `syncWorkerTickerPeriod` from 1 hour to 5 minutes so that ticker drift (caused by sync execution time) does not push the next wake-up just under the `pricingSyncInterval` threshold and inadvertently double the effective sync interval.
- Updated the scheduling model comment to accurately describe the relationship between the ticker period and `pricingSyncInterval`, removing the outdated note that implied the 1-hour ticker was a hard lower bound on sync frequency.

## Type of change

- [x] Bug fix
- [ ] Feature
- [ ] Refactor
- [ ] Documentation
- [ ] Chore/CI

## Affected areas

- [x] Core (Go)
- [ ] Transports (HTTP)
- [ ] Providers/Integrations
- [ ] Plugins
- [ ] UI (React)
- [ ] Docs

## How to test

```sh
go test ./framework/modelcatalog/...
```

Set `pricingSyncInterval` to a value near `MinimumPricingSyncIntervalSec` and verify that syncs occur at the expected cadence without doubling.

## Screenshots/Recordings

N/A

## Breaking changes

- [ ] Yes
- [x] No

## Related issues

N/A

## Security considerations

None.

## Checklist

- [ ] I read `docs/contributing/README.md` and followed the guidelines
- [ ] I added/updated tests where appropriate
- [ ] I updated documentation where needed
- [ ] I verified builds succeed (Go and UI)
- [ ] I verified the CI pipeline passes locally if applicable

<!-- This is an auto-generated comment: release notes by coderabbit.ai -->

## Summary by CodeRabbit

* **Bug Fixes**
  * Increased frequency of pricing synchronization checks from hourly intervals to 5-minute intervals, improving update timeliness and overall system reliability across different configurations.

* **Documentation**
  * Updated internal documentation clarifying the pricing synchronization scheduling mechanism and how timing parameters influence sync behavior.

<!-- review_stack_entry_start -->

[![Review Change Stack](https://storage.googleapis.com/coderabbit_public_assets/review-stack-in-coderabbit-ui.svg)](https://app.coderabbit.ai/change-stack/maximhq/bifrost/pull/4023?utm_source=github_walkthrough&utm_medium=github&utm_campaign=change_stack)

<!-- review_stack_entry_end -->

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: Pratham-Mishra04

framework/modelcatalog/config.go

@@ -11,8 +11,9 @@ const (
 	// syncWorkerTickerPeriod is the fixed interval at which the background sync worker
 	// wakes up to check whether a sync is due. This is independent of pricingSyncInterval —
 	// the ticker defines the check granularity, not the sync frequency.
-	// Setting pricingSyncInterval below this value has no effect on actual sync frequency.
-	syncWorkerTickerPeriod = 1 * time.Hour
+	// Kept well below MinimumPricingSyncIntervalSec so the threshold check is not
+	// defeated by ticker drift when pricingSyncInterval is set near the minimum.
+	syncWorkerTickerPeriod = 5 * time.Minute
 
 	ConfigLastPricingSyncKey      = "LastModelPricingSync"
 	ConfigLastParamsSyncKey       = "LastModelParametersSync"

framework/modelcatalog/sync.go

@@ -234,19 +234,16 @@ func (mc *ModelCatalog) loadModelParametersFromDatabase(ctx context.Context) (in
 func (mc *ModelCatalog) startSyncWorker(ctx context.Context) {
 	// IMPORTANT: scheduling model
 	//
-	// The sync worker wakes on a fixed ticker (syncWorkerTickerPeriod = 1h).
-	// On each wake it calls checkAndSyncPricing, which checks:
+	// The sync worker wakes on a fixed ticker (syncWorkerTickerPeriod). On each
+	// wake it checks:
 	//
 	//   time.Since(lastSyncTimestamp) >= pricingSyncInterval
 	//
-	// This means:
-	//   • pricingSyncInterval defines the *minimum elapsed time* between syncs.
-	//   • The actual sync frequency = max(syncWorkerTickerPeriod, pricingSyncInterval).
-	//   • Setting pricingSyncInterval < 1h does NOT increase sync frequency —
-	//     the hourly ticker is the hard lower bound on check granularity.
-	//
-	// Design rationale: avoids high-frequency polling while allowing operators to
-	// tune how stale pricing data can get (e.g., 1h vs 24h vs 7d).
+	// pricingSyncInterval defines the minimum elapsed time between syncs. The
+	// ticker period is the check granularity and must stay well below the
+	// minimum supported pricingSyncInterval, otherwise ticker drift (the few
+	// seconds a sync takes to complete) pushes the next check just under the
+	// threshold and the effective cadence doubles.
 	mc.syncTicker = time.NewTicker(syncWorkerTickerPeriod)
 	mc.wg.Add(1)
 	go mc.syncWorker(ctx)