Support runtime-evaluated schema values

[Yuliia7-1]

Currently, we want the ability to pass dynamic enum values to RubyLLM schemas. For example, we want to be able to define a schema like this:

module Schemas
  class SummarySchema < RubyLLM::Schema
    def initialize(user_params: {})
      @user_params = user_params
    end

    array :users, description: "List of users to be created", required: false do
      object do
        string :name,
               enum: -> @user_params[:user_names],
               required: false

        array :tool_names,
              of: :string,
              enum: -> @user_params[:tool_names],
              required: true
      end
    end
  end
end

Goal:

• Enable passing custom enum values to schema fields dynamically.
• Support using lambda or proc to provide enum values at initialization.

Benefit:
This will make the schemas more flexible and reusable with dynamic input parameters.

[crmne]

I think we should broaden this beyond enum, since the underlying need is runtime-evaluated schema values rather than custom enum handling specifically.

Proposed direction:

• Model this after RubyLLM::Agent's runtime input pattern.
• Add schema-level inputs, so schemas can declare runtime values and evaluate procs/lambdas against a schema instance context.
• Resolve lazy values when rendering to_json_schema, not when the class DSL is evaluated.
• Apply this broadly to schema values such as enum, description, pattern, format, numeric constraints, array constraints, nested items, anyOf, oneOf, and $defs.
• Avoid making structural DSL decisions dynamic in the initial implementation.

Out of scope for the first pass:

• Dynamic property names
• Dynamic field declarations
• Dynamic of: / references
• Dynamic union branch structure
• Dynamic required:

required: is the one structural option that could plausibly be dynamic later, but it would require changing how required properties are stored and rendered. I do not think we need that for the initial 1.0 scope.

Example target API:

class SummarySchema < RubyLLM::Schema
  inputs :user_names, :tool_names

  string :name, enum: -> { user_names }

  array :tool_names,
        of: :string,
        enum: -> { tool_names }
end

SummarySchema.new(
  user_names: ["Alice", "Bob"],
  tool_names: ["search", "calendar"]
).to_json_schema

We should also continue supporting instance state for custom initializers:

string :name, enum: -> { @user_params[:user_names] }

Implementation note: rendering should resolve lazy values on a deep copy of the schema data so class-level schema templates are not mutated between instances.