the following might work

x.flatMap(a ?=> ... )

for now there is this

scala> inline def givenAs[T, U](inline f: T ?=> U): T => U = t => f(using t)
def givenAs[T, U](f: (T) ?=> U): T => U
scala> List(1).map(givenAs(a ?=> a)) 
val res2: List[Int] = List(1)
scala> List(1).map(givenAs(summon[Int] + 1)) 
val res3: List[Int] = List(2)

Is there any plans on adding this syntactic sugar back in for givens?

No, but an alternative to:

x.myMethod(foo =>
 given Foo = foo
 bla(foo)
)

is to define in Foo (inline to make it zero-cost):

inline def foo(using foo: Foo): Foo = foo

and then one can simply write:

import Foo.foo
x.myMethod(bla(foo))

This has the advantage that every user of myMethod will refer to the given parameter with the same name instead of everyone having to give the lambda parameter a name. This is the style we use in the compiler itself for referring to the current Context: https://github.com/lampepfl/dotty/blob/54929c2398d99c2418e526ddf59efc460bb89975/compiler/src/dotty/tools/dotc/core/Contexts.scala#L59

Having a similar case. In Scala 2, since there is no implicit function parameter, I have a lot of API that looks like

trait Cursor[T] {
 def step[A](body: T => A): A // no implicit function parameter in Scala 2
}
trait Ref[T, A] {
 def apply()(implicit tx: T): A
 def update(value: A)(implicit tx: T): Unit
}

And the use site

trait Example[T] {
 def ref: Ref[T, Int]
 
 def run(cursor: Cursor[T]): Unit =
 cursor.step { implicit tx =>
 ref() = ref() + 1
 }
}

So this makes use of the convenience to prefix the lambda's parameter tx with modifier implicit, which has no Scala 3 equivalent. So I was thinking that this would be cursor.step { (given tx) => ... } but apparently not. So have to resort to the Scala 2 keyword implicit.

You can use pattern-bound given with a pattern-matching function. You'll need to always specify type, however

x.flatMap { case a @ given SomeType => ... } // assuming standard flatmap of `A => F[B]`
// - or - //
x.flatMap { case given SomeType => ... } // if you don't need the name of parameter