La serialización de Boost con estructuras de datos recursivas acaba en desbordamiento de pila.

Problema

Tengo problemas al usar la biblioteca de serialización Boost con una estructura recursiva de datos. Más concretamente, quiero serializar una matriz que está representada por nodos que contienen un valor, y donde cada nodo tiene acceso a sus vecinos (arriba, abajo, izquierda, derecha). Para acceder a un nodo, se almacena cada punto de entrada en un vector (que es el primer y último nodo de cada fila y columna). Aquí está la clase Node:

class Node
{
private:
    int v;
    Node* left; 
    Node* right;
    Node* top;
    Node* bottom;

public:
    Node() : v(rand() % 100), left(NULL), right(NULL), top(NULL), bottom(NULL)
    {

    }

    //Posible fugas de memoria, pero ese no es el tema
    void setLeft(Node* toSet) { left = toSet; }
    void setRight(Node* toSet) { right = toSet; }
    void setTop(Node* toSet) { top = toSet; }
    void setBottom(Node* toSet) { bottom = toSet; }

    Node* gLeft() { return left; }
    Node* gRight() { return right; }
    Node* gTop() { return top; }
    Node* gBottom() { return bottom; }

    int gValue() { return v; }

    template<class Archive>
    void serialize(Archive& ar, const unsigned int version)
    {
        ar& v;
        ar& left;
        ar& right;
        ar& top;
        ar& bottom;
    }
};

Aquí está la clase Matrix, con una función generateValues() para este ejemplo:

class Matrix
{
private:
    int m, n;
    std::vector<Node*> firstNodesPerRow;
    std::vector<Node*> lastNodesPerRow;
    std::vector<Node*> firstNodesPerCol;
    std::vector<Node*> lastNodesPerCol;
public:
    Matrix(int m, int n) : 
        m(m), n(n),
        firstNodesPerRow(m, NULL), lastNodesPerRow(m,NULL),
        firstNodesPerCol(n, NULL),lastNodesPerCol(n, NULL)
    {

    }

    void generateValues()
    {
        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < n; j++)
            {
                Node* toWrite = new Node();
                if (i > 0)
                {
                    toWrite->setTop(lastNodesPerCol.at(j));
                    lastNodesPerCol.at(j)->setBottom(toWrite);
                    lastNodesPerCol.at(j) = toWrite;
                }
                else
                {
                    firstNodesPerCol.at(j) = toWrite;
                    lastNodesPerCol.at(j) = toWrite;
                }
                if (j > 0)
                {
                    toWrite->setLeft(lastNodesPerRow.at(i));
                    lastNodesPerRow.at(i)->setRight(toWrite);
                    lastNodesPerRow.at(i) = toWrite;
                }
                else
                {
                    firstNodesPerRow.at(i) = toWrite;
                    lastNodesPerRow.at(i) = toWrite;
                }
            }
        }
    }

    template<class Archive>
    void serialize(Archive& ar, const unsigned int version)
    {
        ar& m;
        ar& n;
        ar& firstNodesPerRow;
        ar& firstNodesPerCol;
        ar& lastNodesPerRow;
        ar& lastNodesPerCol;
    }
};

Entonces, lo que quiero lograr es la serialización y deserialización de una matriz. Aquí está mi función main:

#include <cstdlib>
#include <sstream>
#include <vector>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/vector.hpp>

int main(int argc, char* argv[])
{
    int m = 10; int n = 10;
    Matrix toSerialize(m,n);
    toSerialize.generateValues();

    /*
        1) Serialize
    */
    std::ostringstream oss;
    boost::archive::text_oarchive oa(oss);
    oa << toSerialize;

    std::string serialiazedData = oss.str();

    /*
        2) Deserialize
    */
    Matrix result(m,n);
    std::stringstream serializedDataStream(serialiazedData);
    boost::archive::text_iarchive ia(serializedDataStream);
    ia >> result;

    return EXIT_SUCCESS;
}

El problema es el siguiente: dado un valor suficientemente grande de m o n, main termina con una excepción de stack-overflow. Sé que proviene del método de serialize de Node, porque para serializar un nodo, necesita serializar los vecinos y así sucesivamente… Encontré este tema que parece que es exactamente la misma pregunta. La respuesta es interesante como punto de partida, pero tengo problemas para implementarla porque no es suficientemente precisa. Lo que entiendo es que para resolver mi problema, necesito:

1. serializar los nodos de manera iterativa, de modo que cuando se trate de los vecinos, los objetos ya estén serializados y no haya un stack-overflow;
2. serializar la topología, que está representada en mi caso a través de los punteros top, bottom, right, left de Node.

Tengo problemas para implementar esta solución, porque la única forma en que puedo imaginar hacer el punto 1 implica eliminar la serialización de top, bottom, right, left en el método serialize de Node, pero ¿cómo logro el punto 2?

Edit: Hice un diagrama de una matriz para ayudar a leer. Tenga en cuenta que no necesariamente hay m