If you don't want to use Reflection, then you may not want to use generics. Here is a code that allows to do this:

interface IUntypedField { }

abstract class Field
{
    protected Field(Type type)
    {
        FieldType = type;
    }

    public Type FieldType { get; private set; }
}

class Field<TValue> : Field, IUntypedField {

    public Field()
        : base(typeof(TValue))
    {
    }
}

interface IFieldMap
{
    void Put(Field field, object value);
    object Get(Field field);
}

class MapCopier
{
    void Copy(IEnumerable<IUntypedField> fields, IFieldMap from, IFieldMap to)
    {
        foreach (var field in fields)
        {
            Field f = field as Field;
            if (f != null)
            {
                Copy(f, from, to);
            }
        }
    }

    void Copy(Field field, IFieldMap from, IFieldMap to)
    {
        to.Put(field, from.Get(field));
    }
}

In this code, each Field derives from a class that carries the field type dynamically (not using generics), but you still have the generic class. You will see this kind of pattern in the .NET Framework itself, notably in the System.ServiceModel class (around Channel/ChannelFactory types).

The drawback is in this case you must de-generize the IFieldMap interface. However, it's possible that when you implement it, you see that you could not work with generics there either.

Another possibility would be to add the FieldType property directly on the IUntypedField avoiding the abstract class Field.