Map with immutable target

Nobody has claimed this yet.

(not really a bug, but more of an improvement)

Mapstruct apparently offers no way to map with an immutable "target".

**Context:**
We have a CarDto and a Car that are both immutable and use a builder generated via Lombok

```java
@Value
@Builder(toBuilder=true)
class Car {
final String color;
final double price;
final int hiddenField;
}

@Value
@Builder(toBuilder=true)
class CarDto {
final String color;
final double price;
}
```
A standard mapping like
```java
@Mapper
class CarMapper {
Car toEntity(CarDto dto);
}
```
works as intended. The generated mapper creates a new CarBuilder, fill the fields and then return the built entity

**The issue:**
As we have `hiddenField` which is not present in the DTO, when we have an API call to update the `Car` entity we need to map the given DTO to the existing entity to preserve the value of the field.

So naively I'd do:
```java
@Mapper
class CarMapper {
Car toEntity(CarDto dto, @MappingTarget Car existingCar);
}
```

However mapstruct doesn't seem to support this use case with an immutable target. And as the documentation clearly states:
> you may also set the method’s return type to the type of the target parameter, which will cause the generated implementation to update the passed mapping target and return it as well.

So yeah, it does not create a copy of the `Car`, it tries to update the given one... And as there are no setter, it doesn't do anything.

As mapstruct supports the builder pattern for regular mapping, it'd be great if mapstruct could get the existing entity, call `toBuilder` on it and then do the mapping as usual.

Start with MapStruct's existing builder support and @MappingTarget handling, using the Car and CarDto examples in this issue as the expected scenario. Determine how an immutable target could be copied through toBuilder(), mapped, and returned while preserving fields absent from the source; done means this behavior is supported without setters.

Written by the indexing model from the issue text.