fix: remove @util.Throttle use

[jleinenbach]

Use of @util.Throttle in Version 4.13.2

In Home Assistant 2024, applying the @util.Throttle decorator to asynchronous functions is discouraged because it was originally designed for synchronous functions. Using it on async functions can lead to unexpected behavior, including blocking the event loop, which hampers the integration's performance and responsiveness.

Problem:
The @util.Throttle decorator restricts how frequently a function can be called. However, when used with asynchronous functions (async def), it fails to properly handle coroutines, leading to potential over-execution or missed executions. This disrupts the integration's ability to manage asynchronous tasks efficiently, resulting in performance degradation or inconsistent states.

Solution:
Replace the @util.Throttle decorator with a custom, asynchronous throttling mechanism using asyncio.Lock and timestamp tracking within the setup_alexa function. This approach ensures that the function executes only after a specified cooldown period has elapsed, without blocking the event loop or relying on global variables.

Benefits of This Approach:

• Non-Blocking Execution: The use of asyncio.Lock and timestamp tracking ensures that the event loop remains unblocked, allowing other asynchronous tasks to run smoothly.
• Accurate Throttling: Guarantees that update_dnd_state is invoked no more frequently than the specified cooldown period, preventing excessive API calls and reducing resource consumption.
• Encapsulation of State: Throttling state (last_dnd_update_times) and the lock (dnd_update_lock) are encapsulated within the setup_alexa function, avoiding the use of global variables and maintaining clean state management.
• Thread Safety: The use of asyncio.Lock ensures that only one coroutine can modify the throttling state at a time, preventing race conditions.
• Enhanced Maintainability: Clear separation of concerns and adherence to asynchronous best practices improve code readability and ease future maintenance.
• Robust Error Handling: Specific exception handling ensures that errors during the DND state update are properly logged and managed, enhancing the integration's reliability.

Potential Issues Without This Change:

• Event Loop Blockage: Continuing to use @util.Throttle on async functions can block the event loop, causing delays and unresponsiveness in the integration.
• Excessive API Calls: Without proper throttling, the function may execute too frequently, leading to API rate limits being exceeded or unnecessary load on the system.
• Inconsistent States: Missed throttling can result in inconsistent DND states, negatively impacting user experience and system reliability.
• Global State Conflicts: Utilizing global variables can lead to unintended side effects, especially in a multi-instance or multi-task asynchronous environment.