Well I honestly wasn't sold on the switch to enforced `Lazy<>` so last night when I was messing around I wound up with something like this:

    public class FactoryManager<T>
    {

        private IDictionary<string, Func<T>> _factories = new Dictionary<string, Func<T>>();

        public IDictionary<string, Func<T>> Factories
        {
            get { return _factories; }
            private set { _factories = value; }
        }

        public FactoryManager(IDictionary<CultureInfo, Func<T>> factories)
        {
            foreach (KeyValuePair<CultureInfo, Func<T>> kvp in factories)
            {
                SetFactory(kvp.Key, kvp.Value);
            }
        }

        /// <summary>
        /// Gets the factory for the CultureInfo provided.
        /// If no culture is provided, CultureInfo.CurrentUICulture will be used
        /// </summary>
        public Func<T> GetFactory(CultureInfo culture = null)
        {
            culture = culture ?? CultureInfo.CurrentUICulture;

            Func<T> factory;

            if (_factories.TryGetValue(culture.CompareInfo.Name, out factory))
                return factory;

            return _factories["default"];
        }

        /// <summary>
        /// Set the factory for the culture provided.
        /// </summary>
        public void SetFactory(CultureInfo culture, Func<T> factory)
        {
            _factories[culture.CompareInfo.Name] = factory;
        }

        /// <summary>
        /// Set the default factory for when a culture does not have a
        /// specific factory set.
        /// </summary>
        public void SetDefaultFactory(Func<T> factory)
        {
            _factories["default"] = factory;
        }
    }

with purpose built classes like:

    internal class FormatterFactoryManager : FactoryManager<IFormatter>
    {
        private static readonly Lazy<RomanianFormatter> _lazyRomanianFormatter = new Lazy<RomanianFormatter>();
        private static readonly Lazy<RussianFormatter> _lazyRussianFormatter = new Lazy<RussianFormatter>();
        private static readonly Lazy<ArabicFormatter> _lazyArabicFormatter = new Lazy<ArabicFormatter>();
        private static readonly Lazy<HebrewFormatter> _lazyHebrewFormatter = new Lazy<HebrewFormatter>();
        private static readonly Lazy<CzechSlovakPolishFormatter> _lazyCzechSlovakPolishFormatter = new Lazy<CzechSlovakPolishFormatter>();
        private static readonly Lazy<DefaultFormatter> _defaultFormatter = new Lazy<DefaultFormatter>();

        public FormatterFactoryManager()
            : base(
                new Dictionary<CultureInfo, Func<IFormatter>>
        {
            { new CultureInfo("ro"), () => _lazyRomanianFormatter.Value },
            { new CultureInfo("ru"), () => _lazyRussianFormatter.Value },
            { new CultureInfo("ar"), () => _lazyArabicFormatter.Value },
            { new CultureInfo("he"), () => _lazyHebrewFormatter.Value },
            { new CultureInfo("sk"), () => _lazyCzechSlovakPolishFormatter.Value },
            { new CultureInfo("cs"), () => _lazyCzechSlovakPolishFormatter.Value },
            { new CultureInfo("pl"), () => _lazyCzechSlovakPolishFormatter.Value }
        })
        {
            SetDefaultFactory(() => _defaultFormatter.Value);
        }
    }

and then on `Configurator`

    public static class Configurator
    {

        private static FactoryManager<IFormatter> _formatterFactories = new FormatterFactoryManager();

        public static FactoryManager<IFormatter> FormatterFactories
        {
            get { return _formatterFactories; }
        }

        /// <summary>
        /// The formatter to be used
        /// </summary>
        public static IFormatter Formatter
        {
            get
            {
                return FormatterFactories.GetFactory()();
            }
        }
    }

You guys both seem to be sold on `Lazy<T>` as the public API, though so I can totally make that change if this seems overly complex.