refactor(freertos/idf): Move critical section API to IDF addition headers

- The following IDF API additions are moved to freertos_tasks_c_additions.h
(implementation) and freertos_idf_additions_priv.h (declaration) as APIs are
private. This reduces the source code difference from upstream.
    - prvENTER_CRITICAL_OR_SUSPEND_ALL()
    - prvEXIT_CRITICAL_OR_RESUME_ALL()
    - prvENTER_CRITICAL_OR_MASK_ISR()
    - prvEXIT_CRITICAL_OR_UNMASK_ISR()
    - vTaskTakeKernelLock()
    - vTaskReleaseKernelLock()
- Rename vTask[Take/Release]KernelLock() to prv[Take/Release]KernelLock() to
indicate that the this API is private.

components/freertos/esp_additions/include/esp_private/freertos_idf_additions_priv.h

@@ -24,6 +24,79 @@
  * KERNEL CONTROL (PRIVATE)
  *----------------------------------------------------------------------------*/
 
+/*
+ * The following macros are convenience macros used to account for different
+ * thread safety behavior between Vanilla FreeRTOS (i.e., single-core) and ESP-IDF
+ * FreeRTOS (i.e., multi-core SMP).
+ *
+ * For thread saftey...
+ *
+ * - Vanilla FreeRTOS will use the following for thread safety (depending on situation)
+ *      - `vTaskSuspendAll()`/`xTaskResumeAll()` for non-deterministic operations
+ *      - Critical sections or disabling interrupts for deterministic operations
+ * - ESP-IDF FreeRTOS will always use critical sections (determinism is not supported)
+ *
+ * [refactor-todo]: Define these locally in each kernel source file (IDF-8161)
+ */
+#if ( !CONFIG_FREERTOS_SMP && ( configNUM_CORES > 1 ) )
+
+    #define prvENTER_CRITICAL_OR_SUSPEND_ALL( x )    taskENTER_CRITICAL( ( x ) )
+    #define prvEXIT_CRITICAL_OR_RESUME_ALL( x )      ( { taskEXIT_CRITICAL( ( x ) ); pdFALSE; } )
+    #define prvENTER_CRITICAL_OR_MASK_ISR( pxLock, uxInterruptStatus ) \
+    {                                                                  \
+        taskENTER_CRITICAL_ISR( ( pxLock ) );                          \
+        ( void ) ( uxInterruptStatus );                                \
+    }
+    #define prvEXIT_CRITICAL_OR_UNMASK_ISR( pxLock, uxInterruptStatus ) \
+    {                                                                   \
+        taskEXIT_CRITICAL_ISR( ( pxLock ) );                            \
+        ( void ) ( uxInterruptStatus );                                 \
+    }
+
+#elif ( !CONFIG_FREERTOS_SMP && ( configNUM_CORES == 1 ) )
+
+    #define prvENTER_CRITICAL_OR_SUSPEND_ALL( x )    ( { vTaskSuspendAll(); ( void ) ( x ); } )
+    #define prvEXIT_CRITICAL_OR_RESUME_ALL( x )      xTaskResumeAll()
+    #define prvENTER_CRITICAL_OR_MASK_ISR( pxLock, uxInterruptStatus )  \
+    {                                                                   \
+        ( uxInterruptStatus ) = portSET_INTERRUPT_MASK_FROM_ISR();      \
+        ( void ) ( pxLock );                                            \
+    }
+    #define prvEXIT_CRITICAL_OR_UNMASK_ISR( pxLock, uxInterruptStatus )  \
+    {                                                                    \
+        portCLEAR_INTERRUPT_MASK_FROM_ISR( ( uxInterruptStatus ) );      \
+        ( void ) ( pxLock );                                             \
+    }
+
+#endif /* ( !CONFIG_FREERTOS_SMP && ( configNUM_CORES == 1 ) ) */
+
+/*
+ * In ESP-IDF FreeRTOS (i.e., multi-core SMP) uses spinlocks to protect different
+ * groups of data. This function is a wrapper to take the "xKernelLock" spinlock
+ * of tasks.c.
+ *
+ * This lock is taken whenever any of the kernel's data structures are
+ * accessed/modified, such as when adding/removing tasks to/from the delayed
+ * task list or various event lists.
+ *
+ * In more cases, kernel data structures are not accessed by functions outside
+ * tasks.c. Thus, all accesses of the kernel data structures inside tasks.c will
+ * handle the taking/releasing of the "xKerneLock".
+ *
+ * This functions is meant to be called by xEventGroupSetBits() and
+ * vEventGroupDelete() as both those functions will directly access event lists
+ * (which are kernel data structures). Thus, a wrapper function must be provided
+ * to take/release the "xKernelLock" from outside tasks.c.
+ *
+ * [refactor-todo]: Extern this locally in event groups (IDF-8161)
+ */
+#if ( !CONFIG_FREERTOS_SMP && ( configNUM_CORES > 1 ) )
+
+    void prvTakeKernelLock( void );
+    void prvReleaseKernelLock( void );
+
+#endif /* ( !CONFIG_FREERTOS_SMP && ( configNUM_CORES > 1 ) ) */
+
 #if ( CONFIG_FREERTOS_SMP && ( configNUM_CORES > 1 ) )
 
 /**