fix: update allocation delay fields immediately for newly registered operators

Addresses audit finding L-01: State inconsistency for new operator allocation delay.

When a new operator registers and their allocation delay is set via DelegationManager,
_setAllocationDelay now also updates info.delay and info.isSet immediately,
not just pendingDelay. This ensures storage consistency where the raw
AllocationDelayInfo struct reflects the effective delay immediately.

Changes:
- AllocationManager._setAllocationDelay(): Set delay and isSet when newlyRegistered=true
- IAllocationManager: Updated NatSpec for AllocationDelayInfo struct
- AllocationManagerHarness: Added getAllocationDelayInfoRaw() for testing raw storage
- Unit tests: Added tests verifying storage consistency
- Docs: Updated setAllocationDelay effects

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: ypatil12

docs/core/AllocationManager.md

@@ -990,8 +990,8 @@ The allocation delay's primary purpose is to give stakers delegated to an operat
 
 *Effects*:
 * Sets the operator's `pendingDelay` to the proposed `delay`, and save the `effectBlock` at which the `pendingDelay` can be activated
-    * If a newly registered operator in core, `effectBlock = uint32(block.number)`, allowing operators to allocate slashable stake immediately after registration
-    * Else, `effectBlock = uint32(block.number) + ALLOCATION_CONFIGURATION_DELAY + 1`
+    * For newly registered operators (called by DelegationManager): Sets `delay`, `isSet`, and `pendingDelay` immediately with `effectBlock = uint32(block.number)`, ensuring storage consistency and allowing operators to allocate slashable stake immediately after registration.
+    * For existing operators: Sets `pendingDelay` and `effectBlock = uint32(block.number) + ALLOCATION_CONFIGURATION_DELAY + 1`. The `delay` and `isSet` fields are updated when the pending delay is applied.
 * If the operator has a `pendingDelay`, and if the `effectBlock` has passed, sets the operator's `delay` to the `pendingDelay` value
     * This also sets the `isSet` boolean to `true` to indicate that the operator's `delay`, even if 0, was set intentionally
 * Emits an `AllocationDelaySet` event

pkg/bindings/AllocationManager/binding.go

@@ -605,7 +605,9 @@ contract AllocationManager is
         /// If the caller is the delegationManager, the operator is newly registered
         /// This results in *newly-registered* operators in the core protocol to have their allocation delay effective immediately
         if (newlyRegistered) {
-            // The delay takes effect immediately
+            // Update delay and isSet immediately for storage consistency
+            info.delay = delay;
+            info.isSet = true;
             info.effectBlock = uint32(block.number);
         } else {
             // Wait the entire configuration delay before the delay takes effect

pkg/bindings/AllocationManagerView/binding.go

@@ -93,12 +93,11 @@ interface IAllocationManagerTypes {
         uint32 effectBlock;
     }
 
-    /// @notice Struct containing allocation delay metadata for a given operator.
-    /// @param delay Current allocation delay
-    /// @param isSet Whether the operator has initially set an allocation delay. Note that this could be false but the
-    /// block.number >= effectBlock in which we consider their delay to be configured and active.
-    /// @param pendingDelay The delay that will take effect after `effectBlock`
-    /// @param effectBlock The block number after which a pending delay will take effect
+    /// @notice Allocation delay configuration for an operator.
+    /// @param delay The current effective allocation delay. Updated immediately for newly registered operators.
+    /// @param isSet Whether the allocation delay has been configured. True immediately for newly registered operators.
+    /// @param pendingDelay The allocation delay that will become effective at effectBlock.
+    /// @param effectBlock The block number at which pendingDelay becomes the effective delay.
     struct AllocationDelayInfo {
         uint32 delay;
         bool isSet;