Other than the suspected bug mentioned above your post (and code) is really good. Good work. :)

It seems to me that in your function double_rotation_with_right you should use:
k->right = single_rotation_with_left(k3->right);
and not:
k->left = single_rotation_with_left(k3->right);

You can easilly test this out using with this example insertion sequence:
5, 10, 8

Obviously this will require balancing. To me it seems like your code will mess up the binary tree, creating a circular reference when you balance after having inserted the 8.

Proposed correct code:

Tree *double_rotation_with_right(Tree *k3)
{
//rotate between k1 & k2
k3->right = single_rotation_with_left(k3->right);

//rotate between k3 & k2
return single_rotation_with_right(k3);
}

The implementation crashes if the list is empty, does not work in a multithreaded system, and is far from elegant.

Consider:

/* helper func */
struct Node* reverse(struct Node* current, struct Node* previous)
{
struct Node* next = current->next;
current->next = previous;
if (next)
{
return reverse(next, current);
}
return current;
}

struct Node* reverse(struct Node* aHead)
{
if (aHead)
{
return reverse(aHead, NULL);
{
return NULL;
}