Why can’t my interface be implemented by a property whose setter has restricted visibility in C#?

Unfortunately, an interface member marked protected doesn't behave the way you're expecting.

That modifier is somewhat unusual on interface members, although the C# specification (the draft v8 text (https://github.com/dotnet/csharpstandard/blob/draft-v8/standard/basic-concepts.md#754-protected-access), at least) offers some explanation:

Interface instance members whose accessibility is protected or private protected aren't accessible from its implementing classes or structs; only interfaces deriving from it may access them.

The distinction matters for default implementations of interface members. Here's an example (I've omitted the generic parameter because it doesn't affect this):

public interface IReading {
    public float Adjustment { get; protected set; }
}

public interface IExtendedReading : IReading {
    public float AdvanceAdjustment() => Adjustment++;
}

An explicit implementation in the concrete class lets you avoid exposing a publicly accessible setter, using either an auto-implemented property:

public class Reading : IReading {
    float IReading.Adjustment { get; set; }
}

... or implementing the accessors in full:

public class Reading : IReading {
    private float adjustment;
    float IReading.Adjustment {
        get => adjustment;
        set => adjustment = value;
    }
}

The setter then isn't exposed publicly to other classes, though this still doesn't achieve the behavior you're seeking.

An abstract class may be a better choice than an interface for this.

ed_fern's explanation covers this well. I therefore won't repeat that discussion.

My recommendation is to put a property with just a getter in the interface. That's the part exposed publicly regardless, including when the modifier is protected. The implementation can then supply a setter with whichever accessibility you need (private, private protected, protected or public (meaning plain set; without any modifier) or you could use init; rather than set;.

Adding the required modifier to that property is another option. Doing so wouldn't break the interface contract.

public interface IReading<T> {
    public T Adjustment { get; }
}

public class Reading : IReading<float> {
    public float Adjustment { get; protected set; } = 0.0f;
}