The other problem i see with your code is your inheritance is making contracts with classes it should not need to and is really breaking all oop practices. This approach allows for less code and cleaner code but also follows the convention of grouped functionality and multiple inheritance.

interface Mappable {
    public function getMetaData();
    public function setMetaData(array $metaData);
}

abstract class BaseMap implements Mappable {
    protected $metaData = [];

    public function getMetaData() {
        return $this->metaData;
    }   

    public function setMetaData(array $metaData) {
        $this->metaData = $metaData;
    }
}

abstract class Mapper extends BaseMap{
    private $map;

    public function setMap($map) {
        $this->map = $map;
    }

    public function parseData($dataRow) {
        $metaData = $this->getMetaData();
        $parsedDataRow = [];

        foreach($dataRow as $columnName => $columnValue) {
            if(isset($metaData[$columnName]))
                $parsedDataRow[$metaData[$columnName]] = $columnValue;
        }

        return $parsedDataRow;
    }
}

class MapA extends Mapper {
    protected $metaData = [
        'backField1' => 'frontField1',
        'backField2' => 'frontField2'
    ];
}

class MapB extends Mapper {
    protected $metaData = [
        'backFieldA' => 'frontFieldA',
        'backFieldB' => 'frontFieldB'
    ];
}


/* i think the benifits speak for them selfs */
// less code
// less objects 
// clean and readable
// easy to use
$mapA  = new MapA();
$mapA->parseData(['backField1' => 'foo1', 'backField2' => 'bar1']);

$mapB  = new MapB();
$mapB->parseData(['backField1' => 'foo1', 'backField2' => 'bar1']);

I am not a PHP expert, but I can read the code.

When I see this code

// Probably correct
$mapper = new Mapper(new MapA());
print_r($mapper->parseData(['backField1' => 'foo1', 'backField2' => 'bar1']));

Then I think to myself, why do I need to instantiate a Mapper with MapA.
I would want to have 1 class that both holds the data and knows how to map.
I would want class Mapper to extend BaseMap and MapA to extend Mapper

Then, I can simply

$mapper = new MapA();
print_r($mapper->parseData(['backField1' => 'foo1', 'backField2' => 'bar1']));

Granted, MapA might not be the best name, you could have used the name of the real mapping method.

Edit:

The counter argument for that is that this leaves the current design flexible, one could use different Mapper classes. My counter counter argument; that feature is not intuitive because the only factory method you have only returns Mapper.

That means that your approach is not caller friendly and not intuitive. If you want to keep the design flexible, then you should remove the static factory method. You could replace it with a comment that points out that this can be used by different mappers.

Finally, you should design with YAGNI in mind, refactoring for new requirements is okay.