Solution Explanation:

This problem requires converting a Binary Search Tree (BST) into a sorted circular doubly linked list in-place. The solution utilizes a depth-first search (DFS) approach to traverse the BST and construct the linked list.

Algorithm:

1. Base Case: If the root node is null (empty tree), return null.

2. Recursive Depth-First Search (DFS): The core logic is within the dfs function (or its equivalent in different languages). This function recursively traverses the BST in an inorder fashion (left, node, right). This ensures that the nodes are visited in ascending order of their values, which is necessary for the sorted linked list.

3. Connecting Nodes: For each node visited during the inorder traversal:

   • If prev is not null (meaning we've already processed a node), we link the current node (root) to the previous node (prev) by setting prev.right = root and root.left = prev. This creates the doubly linked list connections.
   • If prev is null (the first node visited), we set head to the current node (root). head will ultimately point to the smallest (first) node in the sorted list.
   • Update prev to the current node (root) to prepare for linking the next node.

4. Creating Circular Link: After the DFS traversal completes, the last node (prev) needs to be connected to the first node (head) to create the circular doubly linked list. This is done by setting prev.right = head and head.left = prev.

5. Return Head: The function returns head, which is the pointer to the smallest node in the sorted circular doubly linked list.

Time Complexity: O(N), where N is the number of nodes in the BST. The DFS traversal visits each node exactly once.

Space Complexity: O(H), where H is the height of the BST. This is due to the recursive call stack used during the DFS traversal. In the worst-case scenario (a skewed tree), H can be equal to N, resulting in O(N) space complexity. In the best-case scenario (a balanced tree), H is log₂N, resulting in O(log₂N) space complexity.

Code Explanation (Python):

class Solution:
    def treeToDoublyList(self, root: 'Optional[Node]') -> 'Optional[Node]':
        def dfs(root):
            nonlocal prev, head  # nonlocal allows modification of variables in outer scope
            if root is None:
                return
            dfs(root.left)  # inorder traversal: left subtree first
            if prev:  # if not the first node
                prev.right = root
                root.left = prev
            else:  # first node
                head = root
            prev = root #update previous node
            dfs(root.right) #inorder traversal: right subtree
 
        if root is None:
            return None
        head = prev = None # initialize
        dfs(root)
        prev.right = head  # circular link
        head.left = prev
        return head

The other language implementations follow a very similar structure, adapting the syntax and data structures to each language's specific features. The core algorithmic steps remain consistent across all the provided solutions.