Что же делать с рекурсивными объектами ?

На данный момент SnakeYAML не умеет правильно работать с объектами, которые ссылаются на самих себя (напрямую или через другие объекты). Вот сама проблема. При этом имплементация сериализации (dumping) проще и это работает. Десериализация сложнее и имплементация потребует значительных изменений в коде при создании объектов.
Так как в настоящий момент у меня нет нужды работать с рекурсивными объектами, то никаких телодвижений в данном направлении не наблюдается. Если кому-нибудь захочется это починить, то все будут только рады.
В своё время я спросил у разработчика PyYAML, как это там сделано. Кирилл дал очень полный и исчертывающий ответ. (Спасибо!) К сожалению, в Jav'e не доступны те средства, которые используются для этого в PyYAML - generators. Поэтому импортировать реализацию в SnakeYAML не получится.
Для тех, кто не боится интересных задач привожу здесь ответ Кирилла:

Попробую объяснить так.  Нам дан ориентированный граф (YAML document) с выделенной вершиной - корнем документа.  У каждой вершины есть метка - tag.  Каждому тегу мы можем сопоставить конструктор - функцию, которая принимает в качестве параметра вершину графа и возвращает native object.  Задача состоит в том, чтобы преобразовать весь документ и вернуть native object соответствующий корню документа.

Как это сделать?  Самый простой случай - когда alias-ы вообще не используются.  Тогда граф представляет из себя дерево, корень дерева - это корень документа.  Алгоритм преобразования дерева в объект можно представить так:

чтобы преобразовать узел дерева:
   для sequence node: преобразовываем узлы входящие в
       последовательность (рекурсивно)
   для mapping node: преобразовываем узлы входящие в
       отображение (рекурсивно)
   преобразовываем сам узел и возвращаем его.

Не многим сложней и случай, когда alias-ы допускаются, но не создают циклов в графе.  В этом случае достаточно добавить в алгоритм проверку:

   если узел уже преобразован, вернуть соответствующий объект.

Проблема заключается в том, что делать, когда в документе есть циклы.
Самый простой пример:

--- &A [ *A ]

последовательность в которой один элемент - сама последовательность. Создать такую последовательность в Python-е можно так:

seq = []
seq.append(seq)

Тут важно заметить, что создать рекурсивную структуру за один шаг невозможно.  Здесь процесс преобразования разделен на два шага: создание объекта и заполнение объекта.  Для создания объекта не используются объекты соответствующие другим вершинам графа.  Это подсказывает идею: сперва создать объекты соответствующие всем вершинам документа а затем заполнить их.

Итак, мы разбиваем конструктор на две различные функции: создание и заполнение.  Для создания объекта не требуется знаний про другие вершины документа и соответствующие им объекты, для заполнения - требуются. Алгоритм выглядит так:

для каждой вершины документа:
   создать соответствующий объект.
для каждой вершины документа:
   заполнить соответствующий объект.

Это решает задачу в том случае, если мы способны разбить таким образом каждый конструктор.  К сожалению, это не всегда возможно: для некоторых типов создание и заполнение объекта всегда производится в один шаг. Например, в Python-е есть тип tuple - неизменяемый список, содержимое которого можно указать лишь при создании объекта:

t = (1, 2, 3)

Это делает невозможным создание tuple содержащей саму себя, т.е. объект,
соответствующий документу:

--- !!python/tuple &A [ *A ]

невозможно построить.  Тем не менее, это не значит, что tuple не может входить в сложные рекурсивные структуры.  Например документ:

-- !!python/tuple &A [ [ *A ] ]

можно преобразовать так:

l = []
t = (l,) # это конструктор tuple из одного элемента в Python-е
l.append(t),
return t

а документ:

--- &A [ !!python/tuple [ *A ] ]

так:

l = []
t = (l,)
l.append(t)
return l

Интересно, что в обоих случаях создание объектов происходит одинаково.

Итак, дело усложняется тем, что конструкторы бывают двух видов - такие, в которых создание объектов требует информации про другие вершины и такие - в которых создание и заполнение объекта можно разделить.  Что делать в этом случае?  Назовем вершину A зависимой от вершины B, если для создания объекта, соответствующего вершине A требуется знать объект, соответствующий вершине B.  Классифицировать зависимости в документе не сложно: если конструктор вершины разбивается на два шага: создание и заполнение, то вершина ни от кого не зависит.  Если же конструктор одношаговый, то вершина зависит от своих элементов.

Далее, отсортируем все вершины так, чтобы B находилась перед A когда A зависит от B.  Это делается с помощью так называемой "топологической сортировки" - варианта поиска в глубину в графе.  Если вершины отсортированы в нужном порядке, то к ним можно применять конструкторы, зная что объекты, которые требуются для преобразования вершины к этому времени уже созданы.  Итак, окончательный алгоритм выглядит так:

отсортировать вершины в порядке зависимостей, выдать ошибку если это невозможно.
для каждой вершины в указанном порядке:
   если вершина допускает многошаговый конструктор:
       вызвать первый шаг конструктора - создание объекта
   иначе:
       вызвать конструктор
для каждой вершины в указанном порядке:
   если вершина допускает многошаговый конструктор:
       вызвать второй шаг конструктора - заполнение объекта

Как видно, пример с взаимно рекурсивными списком и tuple вполне соответствует этому алгоритму.  В PyYAML описанные шаги алгоритма не выражены явно, однако по сути используется именно такой подход.

Буду безумно благодарен тому, кто не пожалеет времени перевести сие на английский, чтобы помочь желающим решить проблему.