TerritoryInternal.cs

namespace Nwazet.Commerce.Models {
    [OrchardFeature("Nwazet.Territories")]
    public class TerritoryInternal {
        public virtual int Id { get; set; } //Primary Key
        public virtual string GUID {get; set; } //probably going to need this for import/export
        public virtual IEnumerable<TerritoryInternal> ParentTerritories { get; set; }
        public virtual IEnumerable<TerritoryInternal> ChildTerritories { get; set; }
    }
}

TerritoryPart.cs

namespace Nwazet.Commerce.Models {
    [OrchardFeature("Nwazet.Territories")]
    public class TerritoryPart : ContentPart<TerritoryPartRecord> {
        public string Name {
            get { return Retrieve(r => r.Name); }
            set { Store(r => r.Name, value); }
        }

        private readonly LazyField<IEnumerable<TerritoryPart>> _parentTerritories = 
            new  LazyField<IEnumerable<TerritoryPart>>();
        private readonly LazyField<IEnumerable<TerritoryPart>> _childTerritories = 
            new  LazyField<IEnumerable<TerritoryPart>>();

        public LazyField<IEnumerable<TerritoryPart>> ParentTerritoriesField { get{ return _parentTerritories; } }
        public LazyField<IEnumerable<TerritoryPart>> ChildTerritoriesField { get{ return _childTerritories; } }

        public IEnumerable<TerritoryPart> ParentTerritories {
            get { return _parentTerritories.Value; }
            set { _parentTerritories.Value = value; }
        }

        public IEnumerable<TerritoryPart> ChildTerritories {
            get { return _childTerritories.Value; }
            set { _childTerritories.Value = value; }
        }
    }
}

TerritoryPartDriver.cs

namespace Nwazet.Commerce.Drivers {
    [OrchardFeature("Nwazet.Territories")]
    public TerritoryPartDriver : ContentPartDriver<TerritoryPart> {

        //Import/Export can get messy with regards to the parent and child territories
        protected override void Exporting(TerritoryPart part, ExportContentContext context) {

        }

        protected override void Importing(TerritoryPart part, ImportContentContext context) {

        }
    }
}

TerritoryPartHandler.cs

namespace Nwazet.Commerce.Handlers {
    [OrchardFeature("Nwazet.Territories")]
    public class TerritoryPartHandler : ContentHandler {
        private readonly ITerritoryService _territoryService;

        public TerritoryPartHandler(
            IRepository<TerritoryPartRecord> repository,
            ITerritoryService territoryService
        ){
            Filters.Add(StorageFilter.For(repository));
            _territoryService = territoryService;

            OnInitializing<TerritoryPart>(PropertySetHandlers);
            OnLoaded<TerritoryPart(LazyLoadHandlers);
        }

        void LazyLoadHandlers (LoadContentContext context, TerritoryPart part){
            //Use ITerritoryService to do things right
            part.ParentTerritoriesField.Loader(() => ...);
            part.ChildTerritoriesField.Loader(() => ...);
        }

        static void PropertySetHandlers(InitializingContentContext, TerritoryPart part) {
            //Use ITerritoryService to do things right
            part.ParentTerritoriesField.Setter(parents => ...);
            part.ChildTerritoriesField.Setter(children => ...);

            //Force call to setters if we had a value already
            if (part.ParentTerritoriesField.Value != null)
                part.ParentTerritoriesField.Value = part.ParentTerritoriesField.Value;
            if (part.ChildTerritoriesField.Value != null)
                part.ChildTerritoriesField.Value = part.ChildTerritoriesField.Value;
        }
    }
}

TerritoryPartRecord.cs

namespace Nwazet.Commerce.Models {
    [OrchardFeature("Nwazet.Territories")]
    public class TerritoryPartRecord : ContentPartRecord {
        public virtual string Name { get; set; } //e.g. "Italy"
        public virtual TerritoryIternal Territory { get; set; } //the unique territory info
    }
}