Let's start introducing type annotations for all new code.
For this function, since there's no typed arguments and just a typed (possibly-None) string return value, the format would be:

def uri_template_name(self) -> Optional[str]:
    ...

This'll be coming in 4.0.1.
Should also have a Type in the docs.

Same comment regarding including the type in the signature.

Same comments regarding the version and Type.

We definitely want to catch this during development, but one bad extension can bring down a whole server if this happens in production.
I suggest we conditionalize this based on settings.DEBUG. Something like:

if uri_template_name in templates:
    if settings.DEBUG:
        raise ImproperlyConfigured('some useful message to help them debug this here')
    else:
         logger.error('some useful message here...')


And then, of course, only add to the template if it's not already in there.

Same here as above.
In fact, what could be done is you could have this gather a list of URI templates, then loop over when all this is done to apply the logic detailed above, so it's not duplicated.

And here.

4.0.1.

Wonder if it'd be worth doing:

elif self.uri_template_name == self.name:
    return self.name_plural
else:
    return self.uri_template_name + 's'


Also, let's pull out uri_template_name into a local variable up-front, so that we don't have to re-call the property every time. Maybe also make this method a @cached_property.

This looks fantastic. It's going to save us from all manner of problems down the road as the API grows. Thanks for taking this on :)

Here and the string below, can we put quotes around the first %s, to help ensure it reads as a name and not some word in a sentence?

The % (...) should go on the next line.

Sorry I didn't catch this before, but an important point when localizing text: If there's more than one format string inside, you need to use %(somevar)s rather than %s, and pass in a dictionary fulfilling those variables.
The reason is that this sentence:
"Hello %s, how is your %s?"

Could be localized to something structured more like:
"How is your %s, %s?"

If positional, that could end up being "How is your Bob, day?"
To solve that, we'd do:

_('Hello %(name)s, how is your %(subject)s?')
% {
    'name': ...,
    'subject': ...,
}

For logging, we actually don't want to localize. Otherwise, if a user using, say, Mandarin were to trigger a loggable error, and we had localized this to Mandarin, it would be difficult for an English-speaking administrator to debug the error.
So we can strip localization for logging. We only want it for user-visible messages.

To give a bit more room and make editing easier, multi-line strins are better formatted as:

expected_message = (
    '...'
    '...'
    '...'
)

Ship It!