Build: Standardize Gradle plugin application to plugins {} block across all modules

Expected Behavior

All project modules should consistently use the modern, declarative plugins { ... } block for applying plugins. This ensures consistency across the codebase, aligns with Gradle's best practices, and unifies how internal and external plugins are applied.

Current Behavior

Currently, the build scripts use a mix of the modern plugins {} DSL and the legacy apply plugin: syntax. Inconsistencies exist not only between modules but also regarding how specific plugins are applied.

For example:

1. docs/build.gradle Uses the plugins block for security-kotlin but uses apply plugin for standard plugins like java.

plugins {   // Path : spring-security\docs\spring-security-docs.gradle
	id 'org.antora' version '1.0.0'
	id 'io.spring.antora.generate-antora-yml' version '0.0.1'
	id 'io.spring.convention.repository'
	id 'security-kotlin'
}

apply plugin: 'io.spring.convention.docs'
apply plugin: 'java'

2. core/build.gradle Uses apply plugin for security-kotlin, which contradicts the usage in docs.

plugins {  // Path : spring-security\core\spring-security-core.gradle
    id 'security-nullability'
}

apply plugin: 'io.spring.convention.spring-module'
apply plugin: 'security-kotlin'

3. Widespread Inconsistency Beyond these examples, this pattern of mixing legacy and modern styles—or lacking a unified style—is observed in other functional modules as well (e.g., acl, config, web, etc.). Some modules rely heavily on apply plugin, while others have partially migrated, leading to a fragmented build configuration.

Context

I noticed this inconsistency while reviewing the build scripts.

Inconsistent Style: The same plugin (security-kotlin) is applied differently across modules.

Mixed DSL: Legacy imperative style (apply plugin) is mixed with the declarative plugins block within the same files.

Standardizing this to the plugins {} block will improve readability and make the build logic more uniform and maintainable.

Inspect the plugin declarations in docs/build.gradle and core/build.gradle first, then compare the corresponding build scripts in modules such as acl, config, and web. Identify every legacy apply plugin usage and determine which declarations can use the plugins {} block. Done means all project modules consistently apply internal and external plugins through the modern block without the mixed style described here.