The implicit statement (including implicit none) applies to a scoping unit. Such a thing is defined as
BLOCK construct, derived-type definition, interface body, program unit, or subprogram, excluding all nested scoping units in it
This “excluding all nested scoping units in it” suggests that it may be necessary/desirable to have implicit none in each function and subroutine (collectively, procedures) defined in a module. However, inside procedures contained within a module there is a default mapping based on the host scoping unit. So, with implicit none in the module it isn’t necessary to have that in contained procedures.
This host scoping unit rule applies equally to internal programs. This means that implicit none in the main program covers all procedures contained in it; and that the same applies for internal programs of module procedures. Block constructs see this also, and the implicit statement isn’t even allowed within one of these.
However, external functions/subroutines will not inherit implicit behaviour from a program or module, and modules don’t inherit it from programs/other modules which use them. This clearly makes sense as the implicit typing must be known at compile time and be well defined regardless of their ultimate use.
Further, one cannot apply implicit rules from one program unit to a module it uses, such as in:
implicit none
use somemodule
end program
An implicit statement must follow all use statements.
Equally, a submodule is a program unit in itself, distinct from its ancestors. A module or submodule is a parent, not a host, of a submodule which extends it: the host scoping unit rule doesn’t apply and the submodule doesn’t inherit the mapping rules from its parent. Without an implicit statement in the submodule’s scope the default rules will apply there.
The host scoping unit rule notably doesn’t apply to interface bodies. IanH’s answer motivates that exception, but it’s an important enough thing to re-stress. It has caused much confusion.
module mod
implicit none
interface
subroutine external_sub()
! The default implicit typing rules apply here unless
! there is an implicit statement, such as implicit none.
! Those from the module aren't in force here.
end subroutine
end interface
end module
Regarding the test of removing implicit none from a subroutine: if the code is valid with implicit none then it must be valid and identical without that statement. All entities must be explicitly declared in the former case, so no implicit rules would be applied in the latter.