feat(backend): state persisted objects (#9870)

This PR initiates the rework of Zitadel's backend to state-persisted
objects. This change is a step towards a more scalable and maintainable
architecture.

## Changes

* **New `/backend/v3` package**: A new package structure has been
introduced to house the reworked backend logic. This includes:
* `domain`: Contains the core business logic, commands, and repository
interfaces.
* `storage`: Implements the repository interfaces for database
interactions with new transactional tables.
  * `telemetry`: Provides logging and tracing capabilities.
* **Transactional Tables**: New database tables have been defined for
`instances`, `instance_domains`, `organizations`, and `org_domains`.
* **Projections**: New projections have been created to populate the new
relational tables from the existing event store, ensuring data
consistency during the migration.
* **Repositories**: New repositories provide an abstraction layer for
accessing and manipulating the data in the new tables.
* **Setup**: A new setup step for `TransactionalTables` has been added
to manage the database migrations for the new tables.

This PR lays the foundation for future work to fully transition to
state-persisted objects for these components, which will improve
performance and simplify data access patterns.

This PR initiates the rework of ZITADEL's backend to state-persisted
objects. This is a foundational step towards a new architecture that
will improve performance and maintainability.

The following objects are migrated from event-sourced aggregates to
state-persisted objects:

* Instances
  * incl. Domains
* Orgs
  * incl. Domains

The structure of the new backend implementation follows the software
architecture defined in this [wiki
page](https://github.com/zitadel/zitadel/wiki/Software-Architecturel).

This PR includes:

* The initial implementation of the new transactional repositories for
the objects listed above.
* Projections to populate the new relational tables from the existing
event store.
* Adjustments to the build and test process to accommodate the new
backend structure.

This is a work in progress and further changes will be made to complete
the migration.

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: Iraq Jaber <iraq+github@zitadel.com>
Co-authored-by: Iraq <66622793+kkrime@users.noreply.github.com>
Co-authored-by: Tim Möhlmann <tim+github@zitadel.com>

backend/v3/storage/database/statement.go

@@ -0,0 +1,68 @@
+package database
+
+import (
+	"strconv"
+	"strings"
+)
+
+type Instruction string
+
+const (
+	DefaultInstruction Instruction = "DEFAULT"
+	NowInstruction     Instruction = "NOW()"
+	NullInstruction    Instruction = "NULL"
+)
+
+// StatementBuilder is a helper to build SQL statement.
+type StatementBuilder struct {
+	strings.Builder
+	args         []any
+	existingArgs map[any]string
+}
+
+// WriteArgs adds the argument to the statement and writes the placeholder to the query.
+func (b *StatementBuilder) WriteArg(arg any) {
+	b.WriteString(b.AppendArg(arg))
+}
+
+// WriteArgs adds the arguments to the statement and writes the placeholders to the query.
+// The placeholders are comma separated.
+func (b *StatementBuilder) WriteArgs(args ...any) {
+	for i, arg := range args {
+		if i > 0 {
+			b.WriteString(", ")
+		}
+		b.WriteArg(arg)
+	}
+}
+
+// AppendArg adds the argument to the statement and returns the placeholder.
+func (b *StatementBuilder) AppendArg(arg any) (placeholder string) {
+	if b.existingArgs == nil {
+		b.existingArgs = make(map[any]string)
+	}
+	if placeholder, ok := b.existingArgs[arg]; ok {
+		return placeholder
+	}
+	if instruction, ok := arg.(Instruction); ok {
+		return string(instruction)
+	}
+
+	b.args = append(b.args, arg)
+	placeholder = "$" + strconv.Itoa(len(b.args))
+	b.existingArgs[arg] = placeholder
+	return placeholder
+}
+
+// AppendArgs adds the arguments to the statement and doesn't return the placeholders.
+// If an argument is already added, it will not be added again.
+func (b *StatementBuilder) AppendArgs(args ...any) {
+	for _, arg := range args {
+		b.AppendArg(arg)
+	}
+}
+
+// Args returns the arguments added to the statement.
+func (b *StatementBuilder) Args() []any {
+	return b.args
+}