Add documentation for Params extension

Adds documentation for the Params extension to the extensions guide,
including:
- Overview of input validation with dry-schema
- Installation and setup instructions
- Basic usage examples showing success and failure cases
- Schema class usage for reusing schemas across operations
- Integration with custom methods via operate_on
- Schema inheritance behavior

Author: aaronmallen

docsite/source/extensions.html.md

@@ -169,3 +169,115 @@ end
 ```
 
 ⚠️  Warning: The `:requires_new` option for nested transactions is not yet fully supported.
+
+### Params
+
+The `Params` extension adds input validation support to your operations using [dry-schema](https://dry-rb.org/gems/dry-schema/). When a operation is called, the input will be automatically validated against the defined schema before the operation logic executes. If validation fails, the operation returns a `Failure` with detailed error information without executing the operation body.
+
+Make sure you have dry-schema installed:
+
+```ruby
+gem "dry-schema"
+```
+
+Require and include the extension in your operation class, then define a schema using the `params` class method:
+
+```ruby
+require "dry/operation/extensions/params"
+
+class CreateUser < Dry::Operation
+  include Dry::Operation::Extensions::Params
+
+  params do
+    required(:name).filled(:string)
+    required(:email).filled(:string)
+    optional(:age).maybe(:integer)
+  end
+
+  def call(input)
+    user = step create_user(input)
+    step notify(user)
+    user
+  end
+
+  # ...
+end
+```
+
+When validation succeeds, the operation receives the validated and coerced input:
+
+```ruby
+result = CreateUser.new.call(name: "Alice", email: "[email protected]", age: "25")
+# => Success(user) with age coerced to integer 25
+```
+
+When validation fails, the operation returns a `Failure` tagged with `:invalid_params` and the validation errors, without executing any of the operation's steps:
+
+```ruby
+result = CreateUser.new.call(name: "", email: "invalid")
+# => Failure[:invalid_params, {name: ["must be filled"]}]
+```
+
+#### Using schema classes
+
+You can also pass a pre-defined schema class to `params` instead of a block, which is useful for reusing schemas across multiple operations:
+
+```ruby
+UserSchema = Dry::Schema.Params do
+  required(:name).filled(:string)
+  required(:email).filled(:string)
+  optional(:age).maybe(:integer)
+end
+
+class CreateUser < Dry::Operation
+  include Dry::Operation::Extensions::Params
+
+  params UserSchema
+
+  def call(input)
+    user = step create_user(input)
+    step notify(user)
+    user
+  end
+
+  # ...
+end
+
+class UpdateUser < Dry::Operation
+  include Dry::Operation::Extensions::Params
+
+  params UserSchema  # Reuse the same schema
+
+  def call(input)
+    # ...
+  end
+end
+```
+
+#### Custom wrapped methods
+
+The `params` extension works seamlessly with custom wrapped methods when using `.operate_on`:
+
+```ruby
+class ProcessData < Dry::Operation
+  include Dry::Operation::Extensions::Params
+
+  operate_on :process, :transform
+
+  params do
+    required(:value).filled(:string)
+  end
+
+  def process(input)
+    # input is validated before this executes
+  end
+
+  def transform(input)
+    # input is validated before this executes
+  end
+end
+```
+
+#### Inheritance
+
+Schemas are inherited by subclasses, allowing you to build operation hierarchies with shared validation rules.