fix: recalcular consolidado mensual automáticamente al crear/editar/borrar transacciones

CalcularYGuardarConsolidado solo se ejecutaba al visitar /contabilidad/consolidado,
así que un consolidado ya guardado quedaba desincronizado en cuanto alguien
editaba o borraba una transacción de ese mes. Ahora CreateTransaccion,
UpdateTransaccion y DeleteTransaccion recalculan el consolidado del mes
afectado (y del mes anterior si una edición cambia la fecha de mes). También
aplica a los pagos de cuentas por cobrar/pagar, que ahora crean su
transacción a través de CreateTransaccion en vez de un Create directo.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

pkg/models/contabilidad.go

@@ -234,11 +234,21 @@ func GetAllTransacciones(limit, offset int, search string, filtroTipo string, me
 }
 
 func CreateTransaccion(t *Transaccion) error {
-	return app.Http.Database.DB.Create(t).Error
+	if err := app.Http.Database.DB.Create(t).Error; err != nil {
+		return err
+	}
+	recomputarConsolidadoDeFecha(t.Fecha)
+	return nil
 }
 
+// UpdateTransaccion actualiza una transacción y recalcula el consolidado mensual
+// del mes al que queda asociada. Si además cambió de mes, también recalcula el
+// mes anterior, para que ninguno de los dos quede desincronizado.
 func UpdateTransaccion(t *Transaccion) error {
-	return app.Http.Database.DB.Model(&Transaccion{}).Where("id = ?", t.ID).Updates(map[string]interface{}{
+	var anterior Transaccion
+	tieneAnterior := app.Http.Database.DB.First(&anterior, t.ID).Error == nil
+
+	if err := app.Http.Database.DB.Model(&Transaccion{}).Where("id = ?", t.ID).Updates(map[string]interface{}{
 		"fecha":       t.Fecha,
 		"tipo":        t.Tipo,
 		"descripcion": t.Descripcion,
@@ -248,11 +258,41 @@ func UpdateTransaccion(t *Transaccion) error {
 		"forma_pago":  t.FormaPago,
 		"estado":      t.Estado,
 		"notas":       t.Notas,
-	}).Error
+	}).Error; err != nil {
+		return err
+	}
+
+	recomputarConsolidadoDeFecha(t.Fecha)
+	if tieneAnterior && !mismoMesYAnio(anterior.Fecha, t.Fecha) {
+		recomputarConsolidadoDeFecha(anterior.Fecha)
+	}
+	return nil
 }
 
+// DeleteTransaccion elimina una transacción y recalcula el consolidado mensual
+// del mes al que pertenecía, para que no quede con montos que ya no existen.
 func DeleteTransaccion(id uint) error {
-	return app.Http.Database.DB.Delete(&Transaccion{}, id).Error
+	var t Transaccion
+	tieneFecha := app.Http.Database.DB.First(&t, id).Error == nil
+
+	if err := app.Http.Database.DB.Delete(&Transaccion{}, id).Error; err != nil {
+		return err
+	}
+	if tieneFecha {
+		recomputarConsolidadoDeFecha(t.Fecha)
+	}
+	return nil
+}
+
+func mismoMesYAnio(a, b time.Time) bool {
+	return a.Year() == b.Year() && a.Month() == b.Month()
+}
+
+// recomputarConsolidadoDeFecha recalcula (o crea) el ConsolidadoMensual del mes
+// de la fecha dada. Se ignora el error: el consolidado es derivado y se puede
+// recalcular de nuevo en cualquier momento desde /contabilidad/consolidado.
+func recomputarConsolidadoDeFecha(fecha time.Time) {
+	_, _ = CalcularYGuardarConsolidado(int(fecha.Month()), fecha.Year())
 }
 
 // =============================================================================
@@ -524,7 +564,7 @@ func MarcarCuentaCobroPagada(id uint, fechaPago time.Time) error {
 		Descripcion: desc,
 		Valor:       cc.Valor,
 	}
-	if err := app.Http.Database.DB.Create(t).Error; err != nil {
+	if err := CreateTransaccion(t); err != nil {
 		return fmt.Errorf("no se pudo crear la transacción de pago: %w", err)
 	}
 	return app.Http.Database.DB.Model(&CuentaCobro{}).Where("id = ?", id).Updates(map[string]interface{}{
@@ -603,7 +643,7 @@ func MarcarCuentaPagarPagada(id uint, fechaPago time.Time) error {
 		Valor:       cp.Valor,
 		EntidadID:   &cp.EntidadID,
 	}
-	if err := app.Http.Database.DB.Create(t).Error; err != nil {
+	if err := CreateTransaccion(t); err != nil {
 		return fmt.Errorf("no se pudo crear la transacción de pago: %w", err)
 	}
 	return app.Http.Database.DB.Model(&CuentaPagar{}).Where("id = ?", id).Updates(map[string]interface{}{