If you have an interface like:
```
public interface SampleInterface {
  int getFirst();
  String getSecond();
}
```

which is implemented as:
```
public abstract class SampleImplementor implements SampleInterface {
  public abstract boolean isThird();
}
```

With a concrete implementation of SampleImplementor. When
`PojoBuilderHelper` goes to create the property models, it only checks
for methods on the current class, and super classes - not interfaces. In
the above example, this means the property model will only have "third",
and not "first" or "second". Today, you can manually get around that by
creating a @BsonCreator by hand:

```
public abstract class SampleImplementor implements SampleInterface {
  @BsonCreator
  public static SampleImplementor newInstance(
    @BsonProperty("first") int first,
    @BsonProperty("second") String second,
    @BsonProperty("third") boolean third) {
    return new SampleImplementorImpl(first, second, third);
  }

  public abstract boolean isThird();
}
```

The presence of the `@BsonProperty` on the `@BsonCreator` method will
create the property models. Conversely though, if you want to leverage a
Convention implementation to dynamically create a `InstanceCreator`
that knows how to find `SampleImplementorImpl` above, you won't be able
to. `InstanceCreator` only is provided properties for which
`PropertyModel` exists, so above, since `PojoBuilderHelper` didn't
discover the interface fields, and there is no exposed API to add
property models, your `InstanceCreator` will never be provided the
`first` and `second` fields present on the interface.

Simply put, if you provide the pojo codec a class that is not concrete,
extends an interface for methods, and does not have a @BsonCreator
annotation, there is no way to implement a InstanceCreator
implementation that works. We've worked around this problem for years
and created 700+ hand written @BsonCreator annotations, but, enough is
enough :-)

This fix is relatively straight forward: Update `PojoBuilderHelper` to
scan implementing classes and interfaces, which provides a fully
populated property model.