feat(firestore): array constants and AggregateFunction serialization

[bhshkh]

1. Java and Node allow creating Constants from Slices. We need to support the same in Go. E.g. expr := firestore.ConstantOf([]string{"category1", "category2"})
2. Properly delegate serialization to .toProto() when an AggregateFunction is evaluated within toProtoValue, solving issues when building larger pipeline components containing aggregators. E.g. : below code would fail without the serialization

		res, err = client.Pipeline().Collection(coll.ID).
			Select(Fields("title", "author", "rating")).
			RawStage("aggregate", 
				[]any{
					map[string]any{
						"averageRating": Average("rating"),
					},
					map[string]any{},
				}).
			Execute(ctx).Results().Next()
		if err != nil {
			t.Fatal(err)
		}

The above query currently, gets translated to below rpc request

        {
          "name": "aggregate",
          "args": [
            {
              "mapValue": {
                "fields": {
                  "averageRating": {
                    "mapValue": {}
                  }
                }
              }
            },
            {
              "mapValue": {}
            }
          ]
        }

and receives error "rpc error: code = InvalidArgument desc = Literals are only allowed in a scalar expression."

After fix:

        {
          "name":  "aggregate",
          "args":  [
            {
              "mapValue":  {
                "fields":  {
                  "averageRating":  {
                    "functionValue":  {
                      "name":  "average",
                      "args":  [
                        {
                          "fieldReferenceValue":  "rating"
                        }
                      ]
                    }
                  }
                }
              }
            },
            {
              "mapValue":  {}
            }
          ]
        }

[gemini-code-assist]

Code Review

This pull request adds support for slices and arrays in the ConstantOf function and implements handling for AggregateFunction types within toProtoValue. The review feedback identifies a potential panic in ConstantOf when processing nil values due to unsafe use of reflect.TypeOf and suggests optimizing redundant reflection calls in toProtoValue for better performance and readability.

[daniel-sanche]

LGTM