Java stages for reference: https://github.com/googleapis/java-firestore/blob/6e30a6c11efe5d428607bfd78f82ba7b49497bd9/google-cloud-firestore/src/main/java/com/google/cloud/firestore/Pipeline.java

Node stages for reference: https://github.com/googleapis/google-cloud-node/blob/c26967ca277fdab196ea94f5561e4f451ac1ec8a/handwritten/firestore/dev/src/pipelines/pipelines.ts

1. Java allows the user to pass in Fields into remove fields. E.g. user can do in Java .removeFields(field("published"), field("genre"), field("nestedField")) but in Go user cannot do RemoveFields(FieldOf("published"), FieldOf("genre"), FieldOf("nestedField")). This PR fixes this by allowing FieldOf in RemoveFields args
2. Change unnest signature to a more Go idiomatic one
   1. Idiomatic Go Design: Replaced the struct pointer (*UnnestOptions) with a variadic slice of interfaces (...UnnestOption). This standardizes developer ergonomics and aligns with other areas of the Firestore Go SDK.
   2. Cleaner Zero-value Defaults: Callers are no longer forced to pass nil if they don't wish to supply specific configuration arguments.
   3. Better Hygeine & Robustness: Internal logic initializes default underlying representations implicitly without requiring users to instantiate or check nil pointer values.
3. Refactored the Sample stage
   The changes to the sample stage from SampleSpec to Sampler, and SampleByDocuments to ByDocuments were driven by idiomatic Go design principles regarding readability and removing structural redundancy:

   1. Reducing Stuttering in Code
      In the previous API, calling a sample operation resulted in a redundant "stutter" in the code:

      // Old Way: Read "Sample" "Sample By Documents"
      pipeline.Sample(SampleByDocuments(10))

      By removing the redundant "Sample" prefix in the builder function name, the code now reads much more cleanly like a sentence

      // New Way: Read "Sample" "By Documents"
      pipeline.Sample(ByDocuments(10))

   2. Conciseness and Clarity
      Renaming SampleSpec to Sampler represents idiomatic Go naming conventions. Interfaces or types that perform a single conceptual action or "sample" elements are standardly suffixed with -er (like Reader, Writer, Sampler) rather than -Spec.

   3. Exposing ByPercentage consistently
      In addition to rewriting SampleByDocuments to ByDocuments, the new API now cleanly supports ByPercentage directly too:

      // Old Way:
      pipeline.Sample(&SampleSpec{Size: 0.6, Mode: SampleModePercent})
      
      // New Way: 
      pipeline.Sample(ByPercentage(0.6))

      This is much more expressive than forced instantiation for percentage configurations.

4. Refactored the rawstage
   The RawStage refactoring represents a significant shift from a builder pattern (which is Java-idiomatic) to a direct method invocation with variadic arguments (which is Go-idiomatic). Here is a detailed breakdown of the rationale:

   1. Removing Public API Bloat
      In the previous implementation, RawStage was a publicly exported struct (type RawStage struct). This forced the SDK to export a constructor NewRawStage(), and builder methods like WithArguments() and WithOptions().
      The new API makes rawStage internal (lowercase r). The user now simply calls a direct method on the pipeline (pipeline.RawStage(...)). There are no superfluous constructors or builder methods exposed on the documentation surface.

   2. Idiomatic Go (Direct Method Calls)
      Go prefers passing configuring arguments directly into a method rather than instantiating builder objects. Compare the old chained instantiation against the new design:
      Old Way (Java Builder style):

      client.Pipeline().Collection("books").
            RawStage(
                  NewRawStage("limit").WithArguments(3),
       )

      New Way (Idiomatic Go):

      client.Pipeline().Collection("books").RawStage("limit", []any{3})

      The new syntax is much shorter, easier to read, and accurately describes the intent without boilerplate.

   3. Streamlining Options with Variadics
      The new method RawStage(name string, args []any, opts ...RawStageOptions) safely takes variadic pointers for options. If no options are needed, the caller simply omits them. If they are needed, they can supply any amount of RawStageOptions without calling unique chain builders.

   4. Architectural Alignment across the SDK
      This aligns RawStage with the rest of the module's recent refactors (shifting SampleSpec to Sampler, and *UnnestOptions to ...UnnestOption). It unifies the builder's syntax so developers maintain a standard mental model when chained expressions are invoked.

5. Refactored the AddFields, RemoveFields and Select stages to expect at least one arg similar to Java and Node